LIMONATA PROVIDER 0.8.0 — WINDOWS SHARED AI MODEL

START
1. Extract the complete ZIP into a folder you control.
2. Run Limonata-Provider.exe as your normal Windows user, without administrator rights.
3. Keep the console open; its private local URL opens the control panel.
4. Enter your public LIMO payout address and select Start contributing.
   GPU detection, registration, stage assignment, verified download and an actual
   full-GPU inference probe run automatically. No operator token/config is needed.
5. Stop releases your stage. Closing the console stops its owned native process.
   Later starts reuse the saved identity, payout and verified files.

DEFAULT: ONE MODEL ACROSS CONTRIBUTORS
Shared mode runs one pinned Qwen3 32B Q4_K_M model across two resident layer ranges.
The coordinator assigns a compatible part to your GPU; only that part downloads.
- Stage 1: layers 0–47; 14.99 GB download; at least 18 GB free disk recommended.
- Stage 2: layers 48–63; 5.86 GB download; at least 8 GB free disk recommended.
Initial free-VRAM admission includes model weights, 1,536 MiB overhead and 15%
reserve: 18,623 MiB for stage 1 and 8,379 MiB for stage 2. Actual full-GPU loading
and a real stage inference probe must still succeed. These are admission limits,
not independently attested memory measurements or a performance guarantee.

The whole model answers only when every required stage is ready. Additional
compatible contributors add stage capacity or warm replicas. An unused replica
has no accepted work or reward just for being connected. The native stage stays
loaded between requests and during coordinator reconnection; interrupted model
downloads resume and the complete SHA-256 is checked before loading. A process
restart still needs disk verification and GPU loading. First setup is not instant.
The legacy tensor cache is preserved but is not a complete stage file.

The protocol currently uses context 512, two bounded slots per stage and at most
128 output tokens. It exchanges intermediate activations over outbound WSS and
uses private process pipes locally. No public inbound GPU port is opened. Shared
work is sponsored: no LIMO rewards are enabled for shared-model contribution.
Loss of a required stage can interrupt a request when no compatible warm replica
can recover it. Network latency and actual GPU performance still matter.

ADVANCED MODES
Independent whole-model requests remain explicit: one GPU retains a full Qwen
1.5B, 8B or 32B model that fits, then claims matching jobs. These files are separate
from shared stages (approximately 1.12, 5.03 or 19.76 GB). Complete GPU offload and
real inference are required. Paid independent work may earn settled test LIMO.
Legacy tensor RPC is also explicit and retains its existing public-weight cache
limit. Neither advanced mode silently replaces shared Qwen3 32B with a smaller
model. GPU selection, Install / verify and Detect remain available. The install
button verifies the GPU runtime only; Start retrieves the selected mode's files.

HARDWARE AND SECURITY
Windows 10/11 x64; compatible Vulkan AMD or NVIDIA GPU with a current driver.
AMD does not need CUDA or ROCm. The enumeration/independent b10107 runtime can
require the Microsoft Visual C++ 2015–2022 x64 redistributable:
https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist
The client never installs GPU drivers, disables OS protection, requires admin
rights, or installs automatic background startup. CPU fallback is rejected.

Every stage/runtime has a compiled byte-length and SHA-256 pin. Assignment cannot
select arbitrary code, downloads, commands or paths. The shared native runtime
uses a restricted environment and Windows Job Objects for owned-process cleanup.
Only an authenticated hello after the real stage probe advertises readiness.
Capacity/contact refreshes independently during downloading, loading and inference;
authentication rejection or 45 seconds of stale reports stops contribution.

This unsigned preview is cross-built and protocol-tested on Linux. Physical
Windows AMD/NVIDIA execution and shared-stage GPU performance remain unvalidated
here. Do not disable Windows protections. No hardware attestation is claimed.

IDENTITY AND PRIVACY
The random provider credential is protected by Windows DPAPI for the current
Windows user; the server keeps only its hash. Upgrade using the same account.
Identity, payout and prior caches remain in %LOCALAPPDATA%\Limonata\Provider-v0.2.
Do not delete provider-identity.dat to retry. The app never asks for wallet keys.
The authenticated control panel binds only to 127.0.0.1 and does not expose the
provider credential. Shared stages communicate through private process pipes.
No remote shell, remote desktop, public listener or arbitrary graph is exposed.
Stage files contain public model weights, not chats; conversations are not cached.
The trusted coordinator and selected providers process users' inputs/activations.
Other programs running as your Windows user can access your user-protected data.

Registration is testnet 10777 only. Changing modes may require existing requests
or quotes to finish first; Start retains identity rather than bypassing that guard.
Provider guide: https://limonata.xyz/ai/providers

WORK AND REWARDS
AI mining means useful inference, not proof-of-work hashes or minted coins.
Shared contribution is sponsored and earns no LIMO at present. Accepted shared
participation is counted only for stages actually used by a completed request.
Idle time, VRAM advertised, local tests and unused warm replicas earn no reward.
Historical group response speed belongs to the complete group, not one GPU;
it is not a live hashrate. The public explorer shows measured response history.

Recorded earned credit may include earlier independent paid work. It is cumulative
settlement history, including prior withdrawals, and differs from pending work.
The separately verified escrow withdrawal balance can include both earned credits
and chat refunds; all machines with one payout address show the same balance.
Unavailable values show an em dash. Collection requires the matching wallet's
confirmation and transaction fee. The client never holds a wallet private key.
Work and income are not guaranteed; test LIMO has no monetary value.

UPGRADING
Close the old console, extract the complete 0.8.0 ZIP and run the new executable.
Start defaults to shared Qwen3 32B. Existing DPAPI identity and caches are retained.
Downloading an assigned stage is necessary even if legacy tensor blocks were cached.

BUILD AND VALIDATE
Go 1.25 or later. From ai/windows: go test -race ./... and go vet ./...
Cross-build: GOOS=windows GOARCH=amd64 CGO_ENABLED=0 go build -trimpath .
Package: python3 build.py (optional GO_BINARY selects the Go executable).
This creates limonata-provider-windows-x64-0.8.0.zip,
limonata-provider-source-0.8.0.zip and SHA256SUMS-windows-0.8.0.txt.
Keep sibling weightcache, inference and residentclient source directories intact.
The packager requires the pinned native package at ../.runtime/swarm-windows-package
(or LIMONATA_WINDOWS_STAGE_PACKAGE); it verifies the EXE against resident-manifest.
The runtime package includes its source/build recipe and third-party licenses.
No model weights are included in either release ZIP.

UPSTREAM AND NOTICES
llama.cpp b10107 (MIT), with the narrowly scoped resident-stage patch. The complete
Windows native build uses LLVM-MinGW consistently; no MSVC C++ llama DLL is mixed.
Native build provenance, patches and LLVM/MinGW/Vulkan/SPIR-V/json licenses are in
shared-runtime. Runtime verification remains required for a bundled EXE.
Qwen3-32B Q4_K_M (Apache-2.0), pinned revision:
938a7432affaec9157f883a87164e2646ae17555
https://huggingface.co/Qwen/Qwen3-32B-GGUF/resolve/938a7432affaec9157f883a87164e2646ae17555/LICENSE
Stages are derived from the exact model identified by the full SHA-256 in
resident-manifest.json. Independent 1.5B/8B/32B pins and licenses remain documented
in manifest.json, profiles.go and THIRD_PARTY_NOTICES.txt.

HISTORICAL RELEASE NOTES
The entries below describe earlier versions. Current automatic contribution and
reward behavior is described above; historical sponsored-only restrictions have
changed for funded one-GPU small-model pools.

0.4.0 adds automatic collective admission and a capacity bar. Select Collective
model, then Start provider. The app runs a real local Vulkan inference check,
releases the test model, reports current free VRAM and joins without operator
approval. At least 4 GiB total VRAM and a valid free-memory reading are required.
The pinned runtime must support the selected card and driver; brand alone is not
sufficient. Memory readings refresh while connected and expire on the coordinator.

The first automatic target is Qwen3-32B Q4_K_M (Apache-2.0). Model weights live on
the coordinator and are loaded onto the chosen providers when capacity is enough.
The bar excludes 15% headroom and 1 GiB per GPU, and includes memory reserved for
two 2048-token conversation slots. 100% starts a loading attempt; successful full
offload and health checks are required before the chat becomes available. Extra
requests queue; a second copy needs its own complete GPU allocation.

Automatic collective groups currently serve sponsored requests only and earn no
LIMO. Individual paid requests and existing confirmed rewards remain supported.
Collective payment needs a funded request and a payout contract for that exact
group; no reward is invented from VRAM, connected time or a local test.

The coordinator runs public collective engines in a container without external
network access, credentials or access to its private files. The upstream RPC
engine is experimental; this is not hardware attestation, proof of correct work,
or certification of Windows multi-GPU/WAN performance. Use test hardware.
The saved Provider-v0.2 identity and model cache are reused.

0.4.1 — VERIFIED PUBLIC WEIGHTS CACHE
Collective mode can retain eligible public model weights in the app data folder
under weight-cache. Default maximum 32 GiB; choose 16 GiB or Disabled in the
control panel. The first load fills the cache. Subsequent loads verify SHA256
and reuse local bytes, keeping 2 GiB filesystem space free. Only the embedded
public model catalog is eligible; no conversation tensors are stored. Allow up
to 256 MiB extra live RAM for verification. Disk errors fall back to transfers.
The dashboard shows disk usage and network bytes avoided in this session.
Disable does not delete existing cache. To reclaim it, stop the provider and
delete only weight-cache inside its app data directory, retaining your identity.
This accelerates repeated weight transfers, not token generation. Qwen3-32B
Q4_K_M has about 92% eligible bytes; available disk and layer assignment affect
actual savings. Native Vulkan libraries and RPC version b10107 are unchanged.

0.5.0 — ONE-CLICK AUTOMATIC AI CONTRIBUTION
Start now performs setup, GPU selection, inference validation and registration
in one action. Manual settings remain under Advanced options. The dashboard
shows accepted work and correctly scoped historical output rates, with earned,
pending and verified withdrawable test LIMO shown separately. Native Vulkan
libraries, the saved identity directory and the public-weights cache are retained.

0.5.1 — TEMPORARY NETWORK RECONNECTION
The client keeps its runtime and saved identity while retrying transient tunnel
failures with a delay that increases from 1 to 15 seconds. After a coordinator
restart, temporary tunnel admission failures allow capability reports to restore
access. A revoked credential (HTTP401) or rejected capability report stops sharing.
GPU/heartbeat refresh failures stop sharing once the last successful report is
45 seconds old. Stop interrupts retry delays and in-flight checks. GPU driver,
model validation, cache, isolation and reward accounting behavior are unchanged.

0.5.2 — CACHE TUNNEL HEARTBEATS DURING GPU WORK

The verified weights cache keeps processing WebSocket control frames while the
GPU is computing. Previously a slow GPU response could delay a heartbeat until
the coordinator disconnected the stream. One continuous reader now uses four
fixed 64 KiB buffers, preserving RPC order and bounded backpressure. A closed
remote stream also releases a pending local GPU socket read promptly.

Close the old provider, extract the new archive and run its executable. Your
saved identity, payout, runtime and verified disk cache remain in the existing
profile directory. Runtime and GPU checks are unchanged. Loopback WebSocket
regressions and complete two-CPU RPC model loads/generations pass; validation
of this updated client on physical Windows GPUs remains pending.
