@aryacode/dsh-local-llm 0.0.0-stage → 0.8.2

package/LEGACY-CONTROL-CENTER.md

@@ -0,0 +1,161 @@
+# Local LLM Control Center
+
+An optional AryaAI plugin for computer health, inference engines, model libraries, tuning and measured calibration. It remains useful before installing an inference engine. It does not require a particular GPU, model name, Windows drive or pre-existing AI directory.
+
+## Start here
+
+1. Open **Local LLM → Health** for live CPU, per-core load, RAM, swap, GPUs, temperatures, storage, network and battery readings. Unsupported or timed-out sensors show Unavailable; other readings continue updating. Sensors depend on the operating system, hardware and driver support. Hardware collection uses the maintained systeminformation library on Windows, Linux and macOS; this release has been exercised on Windows.
+2. Open **Engines** to find official installation links or select an existing llama-server executable. The default data directory is your user home’s .arya/local-llm folder. GGUF files live in the selected library folder’s models subfolder. Ollama’s loopback API address is editable. Installing a runtime, downloading a model and starting inference are separate actions; nothing installs or starts automatically.
+3. Open **Models** to load or unload an Ollama model, configure a GGUF model, select its saved profile or delete an inactive model. Deletion asks for confirmation and rejects active or externally managed servers. A failed profile update restores a staged model deletion. Removing one file or retaining one invalid profile does not hide other models.
+4. Choose **Tune model**, review its alias, projector and settings, then save. Lower-memory, balanced and throughput starting points change the form only. They are not claims of optimal settings. Per-model profiles preserve independent settings; invalid profiles remain on disk and appear as individual issues.
+5. Choose **Calibrate** on a model to open its benchmark selection. Quick speed is the initial test, with an 8K requested context. Compare measured first-token latency, decode throughput and memory before increasing context or changing another setting. A benchmark can load and stop engines; review its settings before starting it. API benchmarks retain their explicit spending approval.
+
+## Local, phone and other-computer access
+
+**This computer** manages engines on the AryaAI host. A phone pairs through AryaAI’s **Mobile & Remote** entry and uses that same host’s models and controls; it does not need a separate LLM pairing key. Control requests from a remote browser pass the host Connection service’s existing session and Host/Origin checks. An unauthenticated network client cannot use them.
+
+To use a different computer’s models from another AryaAI installation, choose **Connect another computer**. On the model computer choose **Share this computer’s models**, create a key, then copy its Tailscale address and key into the other AryaAI. Keys authorize local inference, engine management and local benchmarks, not paid provider access. Sharing can be paused and individual keys revoked. Creating or changing computer pairings stays local to the host; a paired browser can use an existing connection.
+
+Strata and llama.cpp expose links to their native web interfaces. Add an optional interface URL, such as a separately installed Open WebUI, in **Engines → existing installation → Engine web interfaces**. Ollama’s API is not presented as a web UI. A loopback engine link is shown only on its own computer: localhost on a phone or another computer refers to that device. Configure a reachable, separately secured engine interface URL to use it there. API URLs and interface URLs remain separate settings.
+
+## Model and engine behavior
+
+The Local model library provider discovers configured GGUF profiles and current Ollama models. Adding or renaming a model does not require editing provider YAML. Removed models are refused on the next request. Model-setting changes invalidate the picker, and a request prepared against older settings asks for a retry instead of combining old metadata with new settings. Plain Ollama models use a conservative 4K request budget; create a tuned variant with an explicit context to advertise another budget. Vision is taken from the model’s reported capabilities or a configured projector.
+
+Only owned llama.cpp processes are stopped. Process identity and creation time are checked; Windows uses its process facilities and POSIX systems use ps and owned process groups. Existing Ollama desktop process controls remain Windows-specific; API model management works through its local API. Strata, FreeToken and NInfer integrations require their optional engine configurations. Their platform and runtime requirements still apply. Invalid optional engine configuration reports an engine-specific error without removing health, setup or other engines’ routes. NInfer’s validated context range is 4,096–102,400 tokens.
+
+Runtime and engine preferences are written atomically. The default profile patch contains no machine-specific paths. Existing explicit profile configuration and saved model settings remain supported. A missing selected model is reported as missing rather than as a download that is not happening. GGUF downloads use staged files and published size/checksum verification. Gated repositories, interrupted-download resume, and automatic runtime installation are not implemented. Download jobs are tracked for the current plugin run. Failed downloads can leave partial files; inspect those before retrying. The control center never switches engines merely because another one is installed.
+
+## Upgrade to 0.6.0
+
+Restart AryaAI after updating the plugin; a page reload does not reload host code. Update both computers in a paired setup. Existing explicit engine paths and saved profiles remain readable. New installations use per-user folders and start without a selected model.
+
+## Build and validation
+
+Run npm install and npm run typecheck, then npm run build and npm test. Development against AryaAI uses that workspace’s built @deepseek-ai/dsh-llm-pi-ai peer; published npm development copies can lack private workspace peers. This package’s runtime peer is supplied by AryaAI, and systeminformation is a declared runtime dependency.
+
+The owning tests cover startup without engines, invalid optional configuration, partial sensor failures, model add/rename/remove, deletion rollback, authenticated browser access, stale prepared requests, live aliases and streaming. Run npm run test:ui with the adjacent AryaAI workspace, or set ARYA_WORKSPACE to its location. PLAYWRIGHT_CHROMIUM_EXECUTABLE can select an installed Chrome or Chromium. UI checks include desktop and narrow layouts, setup, model tuning, calibration entry and engine links. Windows live verification does not establish every engine or sensor on Linux and macOS.
+
+## Benchmark lab
+
+Suite 2.0 provides speed, AryaAI readiness, website/game generation, and coding/automation tests. Eight browser briefs cover product launch, analytics, store/cart, kanban, booking, documentation, Snake and Tetris. Automated checks exercise required interactions at desktop/mobile widths; visual quality is rated separately by the user.
+
+Choose up to six installed models and run them sequentially. Each run saves settings, timing sources, token/cache counts, GPU samples, model startup time and results under the configured model library’s benchmarks directory. JSON export includes the full saved record. Browser checks block network requests; generated HTML is rendered in sandboxed previews; desktop/mobile screenshots support side-by-side comparison.
+
+Cancellation restores original llama.cpp settings and previously owned managed servers. Ollama models are unloaded; prior Ollama model residency is not restored. Stop other chats before testing. Strata uses its configured context; the selector applies to llama.cpp and Ollama. Readiness uses arya-request-header.json and reports its capture time; it does not execute every harness tool.
+
+Browser and coding checks require official Playwright core and Chromium. Set `benchmarkRuntimeDirectory` in the plugin's profile configuration (default `~/.arya/local-llm/benchmarks`), containing `node_modules/playwright-core/index.mjs` and a `browsers/chromium-<revision>` installation. Prerequisites are checked before a run changes model servers. Incomplete output is recorded as a failure, with generation metrics and the raw response in JSON export. The default build/coding output budget is 12,288 tokens.
+
+Validation: node --test tests/control.test.mjs tests/download.test.mjs tests/benchmark.test.mjs.
+
+Benchmark exports: choose **Export ZIP** for an offline results report (`results.html`), full results (`results.json`), generated websites, and available desktop/mobile screenshots. Extract the archive before opening the report. Failed or cancelled runs include available artifacts and identify missing files. JSON export remains available separately.
+
+Per-model tuning is stored in the runtime directory's `model-presets.json`. Each preset specifies an alias, recommended context, threads, CPU expert layers, matching vision projector, GPU layer count, and validated KV cache type. Choosing a model in Runtime settings fills its recommended settings; benchmark runs apply its threads, CPU expert placement, and projector while honoring the comparison's requested context. The starting server settings are restored afterward. Unknown models retain the existing Q8 cache defaults.
+
+## Paired remote hosts (0.4.0)
+
+Install this same plugin on both AryaAI computers. In Connection settings on the model host, create a named pairing key. On the other computer choose the host's HTTPS Tailscale address, paste that key, and click Pair and add models. Remote Local LLM appears as a provider in the chat picker. Connection settings persist under the user's .arya/local-llm/remote.json (override connectionDirectory per profile when sharing one OS account). Host-side pairing keys are hashed; the receiver stores its outbound key privately. Connection views and model inventory exclude keys. Unpair a device or pause sharing on the host to revoke access.
+
+This PC and Remote host select which machine the dashboard controls. Charts, catalog downloads, server/model controls, logs, saved benchmark comparisons, site previews and ZIP/JSON exports work through an authenticated route allowlist. Host benchmarks expose local models only and never authorize paid API usage. Remote inference uses the existing host model adapters, retaining their reasoning and context metadata. AryaAI tools execute on the requesting computer; the host performs inference, not those tool actions. Images transfer through the attachment service. Read project files with AryaAI tools.
+
+Selecting a host llama.cpp model loads its saved preset when idle. Cross-engine GPU contention produces a clear message requiring you to stop/unload the other engine first. Switching between llama.cpp presets is serialized; start failures attempt to restore the prior settings. Tracked AryaAI generation and benchmarks block remote engine changes. Enabled llama.cpp slots and Strata in-flight counters also detect engine activity. Requests from unrelated direct Ollama consumers are not universally observable: finish those tasks before remote Stop/Restart. Sharing remains off until a pairing key is created or explicitly enabled.
+
+Reachability is required: publish the AryaAI host web endpoint over Tailscale HTTPS Serve, without Funnel/public exposure. For this host the URL is https://desktop-n9ueqo4.taila18128.ts.net. Tokens are sent by the plugin host, not attached to browser URLs. Only Tailscale/loopback addresses are accepted; redirects and arbitrary proxy destinations are refused. New catalog downloads are managed files; only models already configured in the host AryaAI adapters are auto-registered in the remote picker.
+
+Reload both AryaAI applications after installing host code. A browser refresh does not reload the Node plugin. Remote deployments can keep dsh-strata off the client: the model host must retain it for Strata controls. The host must retain the benchmark browser runtime and tool snapshot for website/readiness runs.
+
+Validation: npm test; npm run typecheck; native AryaAI source-runtime provider/stream integration; isolated browser checks for pairing, remote/local modes, secret hiding, controls, benchmark routing and narrow screens.
+
+## Tuning studio (0.5.0)
+
+llama.cpp profiles store context, alias, projector, GPU placement, CPU expert layers, threads, logical/physical prompt batches, KV precision, flash attention, MTP or N-gram speculation, draft tokens, backend sampling and sampling defaults. Fields are validated before persistence and converted to separate command-line arguments. Save while the server is stopped, select the model in Servers → Runtime settings, then start it. Saving does not interrupt a server or change its model selection. Client requests may override server sampling defaults; benchmark prompts use fixed sampling for comparisons.
+
+Ollama variants use the official /api/create endpoint with an installed base model and a new name. Supported defaults are context, temperature, top P/K, min P and repetition penalty. Existing names are rejected. Load the new variant from Models or select it in Benchmarks. Benchmark selectors override variant defaults intentionally.
+
+Strata tuning exposes supported numeric flags already present in the configured engine file: maximum context, resident KV tokens, VRAM reserve, speculative draft count, PCIe expert fraction and speculative minimum probability. Save while Strata is stopped. Each write preserves model paths, credentials and other settings, with a timestamped backup beside the configuration. Start Strata to apply values. Paired hosts support the same tuning controls.
+
+## Coding and automation checks
+
+Suite 2.0 adds pending-hours JavaScript generation, JavaScript deduplication repair, PLCopen TC6 XML Structured Text generation, Rockwell routine L5X generation and L5X identification. JavaScript executes in a bounded offline Chromium Worker, never in the Arya host; infinite loops are terminated. XML is parsed without DTDs or external entities, then checked for specified declarations, export metadata and fixture logic. These fixed-task checks are not a PLC compiler, a vendor import certificate or a test on a controller. Equivalent solutions outside a task's requested fixture may fail. Review engineering output and validate it in vendor tools before use.
+
+Engineering checks accept complete JavaScript, XML and JSON Markdown code fences. Identification still validates the decoded fields and tag inventory; a JSON fence does not count as an incorrect engineering answer.
+
+XML syntax is checked with a strict parser before browser inspection. Malformed XML receives zero; browser recovery cannot make it pass. L5X checks require Controller/Programs/Program/Routines/Routine nesting and BOOL Base tag attributes. Historical results retain their original scores unless their saved answers are explicitly regraded.
+
+Snake checks exercise food growth, score, reversal rejection, wall collision and reset. Tetris checks exercise movement, rotation, hard drop, four-line clearing and restart. Both retain desktop/mobile previews and screenshots. Game-state fixtures are declared in each task brief. Coding results retain the response and named checks; expand View generated code to download JavaScript, XML, L5X or JSON. JSON/ZIP exports preserve responses; saved-run comparisons include engineering tasks.
+
+## Upgrade from 0.4.0
+
+Unsloth cards, discovery, lifecycle controls and remote routes are removed. The desktop installation is untouched. Existing llama.cpp settings, profiles, remote pairing and saved benchmark records remain readable. Install 0.5.0 and restart AryaAI to reload host code; a browser refresh alone is insufficient. Update both endpoints in paired setups.
+
+Validation: npm run typecheck; npm run build; npm test; npm run test:ui. Browser tests currently require the owner-local Playwright installation and adjacent AryaAI development dependencies.
+
+## MoE expert cache
+
+Model tuning studio exposes `moeCacheMiB`, a per-model GPU cache budget for CPU-resident MoE experts. The default 0 disables it and preserves existing launch arguments. Positive values add `--moe-cache-mib` and require a supporting llama.cpp build (upstream b11480 or later). This cache uses unchanged expert weights and targets small-batch generation. It consumes VRAM alongside GPU model layers, KV cache, vision and compute buffers; reduce GPU-resident expert layers when necessary. Dense models do not benefit. Compare prompt processing and generation separately at the same context, projector and workload before keeping a setting. Saved profiles apply to local, benchmark and paired-host starts.
+
+## FreeToken in WSL
+
+An optional `freeToken` configuration adds a local FreeToken server card, bounded logs, and tuning under Server controls. It requires Windows, an installed WSL distribution, a dedicated FreeToken Python environment, and a checksum-verified safetensors checkpoint. Existing GGUF profiles remain in llama.cpp. The Control Center does not install WSL, download weights, or migrate a model automatically.
+
+Configure `directory` (Windows control files), `statusFile` (verified downloader manifest), `distribution`, `runtime` (Linux virtual environment), `modelPath` (Linux checkpoint directory), `alias`, `port`, and `defaults` containing `context`, `threads`, `prefill`, `memoryRatio`, `strategy`, and `vision`. The downloader manifest must report `phase: verified-serving-validation-pending` and the matching Linux `directory`. Defaults are explicit deployment settings. For Qwen3.6 NVFP4 on a 16GB Ada GPU, the prepared runtime uses Triton, serial expert loading, automatic WSL CPU expert layers, streamed host vision weights, and an expert cache with a context-sized KV reservation.
+
+Tune context (4K–256K), CPU expert threads, prompt batch size, GPU memory fraction, expert strategy, and vision while the server is stopped. Start is blocked until checkpoint verification and while another local provider is loaded. The helper records Linux process start time and stops only its matching process group; it does not shut down WSL or terminate unrelated processes. The model API binds to loopback. FreeToken controls are local; paired remote controls do not expose this provider yet. A configured context limit is not a successful retrieval test, and supported quantization is not proof that a checkpoint fits available memory.
+
+FreeToken integration validation: plugin type check and build; tuning parser tests; WSL owned-process lifecycle and stale-identity protection with a fake runtime. Model inference and full context validation are separate installation steps.
+
+Run the WSL lifecycle fixture with the runtime Python: python tests/freetoken-control.py scripts/freetoken-control.py. Final provider-tracking checks: pnpm run typecheck; pnpm run build; node --test tests/freetoken.test.mjs tests/remote.test.mjs tests/control.test.mjs (15 passed).
+
+## Switching Strata models
+
+Servers → Strata now offers a Model selector from the plugin's explicit `strataProfiles` list. Each profile supplies `id`, `name`, and a separate engine configuration `path`. Stop Strata, choose Original Qwen Flash or Swift Flash, click Apply model, then Start server. Selecting a chat model name alone does not load different weights; choose the matching chat entry after starting the selected Strata profile.
+
+Switching validates model, pack, runtime and vision files before changing the active configuration. Current tuning is saved into the departing model profile; the active engine configuration receives the selected profile while retaining the current API key. A timestamped backup supports recovery. GUI requests accept only configured ids, not filesystem paths. Active inference, benchmarks and a running Strata server block switching. Profile files must be separate from the managed active configuration. Paired hosts expose the same guarded selector routes.
+
+FreeToken reports ready only when its /health response has status=ok; an available model catalog or a loading health response does not mean inference is ready.
+
+FreeToken checkpoints that have completed checksum verification appear in the benchmark model list. Runs wait for model readiness, apply the selected context, stop each tested engine, and restore the previous FreeToken tuning and owned server along with the other managed engines.
+
+## Model discovery
+
+Discover accepts model-family searches, Hugging Face repository ids and model-page links. Results link to the publisher and sort by downloads, recent updates or likes. Capability filters reflect publisher tags; they do not establish tested vision or tool support. Model details group split GGUF files into complete quantization sets and show aggregate download size. Incomplete sets cannot be downloaded. Optional vision projectors are selected separately. Memory guidance compares selected weight bytes with GPU capacity minus the editable reserve; context, vision execution and working buffers can require more than that reserve.
+
+A complete-model download pins the repository revision when provided, verifies every available SHA256, and publishes files after all selected transfers verify. Existing files are not overwritten. Downloading does not switch servers or register an untested chat model.
+
+Validation: focused discovery tests cover complete and incomplete shard groups, exact repository lookup, catalog sort, aggregate downloads and corrupt-shard rejection. Browser checks cover model links, detail selection, full download totals, light/dark themes and narrow layouts.
+
+## NInfer
+
+For Docker-free serving, add `ninfer.wsl` with `distribution`, an absolute Linux `binary` path and `libraryPath` (WSL driver directory first, then CUDA libraries). The same tuning, benchmark, readiness and log controls manage one WSL process group. PID, Linux start time, executable and command line must match the persisted owner before stopping. WSL mode starts and stops no Docker container; the existing image configuration remains available for rollback. Docker is consulted only to identify a running container that another launcher started from the same pinned image, artifact and port, and that container's log is served while it answers; an explicit takeover is the only path that stops it. Build and validate the binary with CUDA and FFmpeg before enabling this mode.
+
+Configure `ninfer` with an explicit install directory, verified artifact path, Docker image digest, container name and ownership label, port, modelName and validated defaults (context, prefill, hostKvMiB, draftTokens and vision). Servers → NInfer exposes Start, Stop, Restart, readiness, logs and tuning. Controls bind the model API to localhost and refuse foreign container IDs, labels or occupied ports. Settings can be saved only while stopped; start refuses other loaded engines. The pinned MTP profile uses rk4v4-e8 KV, draft windows up to three and disables n-gram chaining. Paired remote controls are not exposed for this engine.
+
+The AryaStrata page shows an NInfer view for these routes on the engine computer: lifecycle controls, tuning while stopped and the log tail. A paired page keeps the Strata-only view, and the routes themselves are unchanged. A container started by another launcher is reported as External, with the same log and a takeover that stops only a container matching the pinned image, artifact and port.
+
+Verified NInfer artifacts appear as local models in Benchmarks. Choose 32K, 64K or 100K; larger requests fail before engines are interrupted. Runs translate thinking into top-level enable_thinking/reasoning_effort, omit llama.cpp chat_template_kwargs, and restore previous NInfer tuning and owned servers. Configured context and short image checks do not establish full-context retrieval or website quality.
+
+Validation covers ownership refusal, stopped settings, local-only control headers, NInfer benchmark request fields and restoration, plus the engine-card and tuning browser flow.
+
+## Slider tuning
+
+Runtime settings and model tuning pair keyboard-accessible sliders with exact-value inputs. Context offers stepped capacities and quick 32K/64K/100K/128K/256K choices within each engine's supported range, displayed in K tokens. Other numeric settings use their existing validated ranges. Moving a slider edits the form; Save remains the explicit application step and existing stopped-server and inference guards apply. Status refreshes preserve draft values until the saved server setting changes. No quick choice promises GPU fit or measured speed.
+
+Validation: browser checks cover quick context choices, slider keyboard adjustment, exact-input synchronization, preserved drafts across polling, saved payloads, stopped-server locks and narrow/light/dark layouts.
+
+## Chat output limits
+
+Models → Chat models lists configured Strata, NInfer, FreeToken, llama.cpp and local Ollama chat models independently of engine discovery, including when engines are stopped or model-file inventory is empty. Each card opens Adjust output tokens with that model selected. Refresh chat models reloads saved settings. The downloaded GGUF and Ollama file library is listed separately.
+
+Tuning opens Chat output by default. Tuning → Chat output edits each configured local chat model's persisted per-response output allowance with a slider, exact value and8K/16K/32K/64K choices. It reads fresh model settings before saving and retains other fields. Thinking, tool arguments and answers share the allowance; this is separate from server context and benchmark budgets. Input plus generated output must fit context. Higher allowances can trigger earlier context compression. Existing in-progress responses retain their admitted limit; subsequent requests use the saved default. Server restart is not required. Remote-host selection does not edit local chat settings; open this panel on the host whose model catalog you want to change.
+
+## Remote managed engines
+
+Version0.5.7 offers configured NInfer and FreeToken models to paired hosts, preserving their thinking choices, image inputs and output defaults. Remote server cards proxy status, logs, Start/Stop/Restart and tuning through the existing pairing checks. Model selection can start the selected managed engine only when other engines are stopped; it never stops another engine automatically. An already healthy selected engine is reused. Configure the runtime and matching provider entry on the sharing host. Update Control Center on both PCs, restart when idle, then choose Connection settings → Refresh models on the remote PC. Runtime context is advertised from its saved settings; this does not establish full-context retrieval.
+
+## Billion-compatible paired inference
+
+Control Center0.5.8 sends paired NInfer and FreeToken inference over the authenticated /api/local-llm/v1/chat/completions endpoint. The maintained Arya OpenAI codec preserves tool calls, thinking, images and usage. The adapter passes the configured context and output budget explicitly so unknown model aliases do not fall back to a larger estimated window. Billion on the client PC can intercept and compress this protocol; the host forwards it directly to its managed loopback engine without a second compression pass. Configured GGUF and Ollama library models also use this wire transport. GET model discovery avoids mistaking inventory traffic for uncompressed inference. Update both PCs; older host versions fail with an update instruction rather than silently taking the native path for these models.
+
+Validation used a real isolated DSH loop, the Local LLM tool filter, Billion0.1.195 and a paired HTTP host with a deterministic model. A successful fold replaced consumed read evidence in the next request and reduced serialized message length from 60,263 to 41,676 characters. The proxy log confirms its 102,400-token window and a successful applied fold. This is a transport/compression test, not a Qwen accuracy benchmark or full100K retrieval test. The user model still must call compress; Local LLM0.2.6 supplies proactive usage guidance.
+
+Validation for 0.5.8: focused remote/authentication, engine and stream checks pass, including rejected external images and interrupted SSE. An isolated real DSH/Billion/paired-host replay confirms consumed evidence is replaced by its summary at configured 32K, 100K and 256K windows, with the actual window passed to Billion. The model in this replay is deterministic; it does not establish autonomous Qwen compression timing or full-window retrieval.

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+# AryaStrata Control Center
+
+An optional AryaAI plugin for the AryaStrata engine, with a second view for the local NInfer Qwen3.8 dense model. The sidebar entry is **AryaStrata**. A **Strata / NInfer** switch chooses the engine on this computer; start, stop and restart it from the header. Strata's own web UI fills the rest of the page for hardware health, inference monitoring and model management, while NInfer's tuning and logs are shown directly. **Open AryaStrata web UI** opens the Strata interface in a separate tab.
+
+## Setup
+
+Keep the `dsh-local-llm` package identity for existing installations and updates. The engine controller is included in this package; no separate controller or agent preset is required. Its routes use `/api/aryastrata`, so an older standalone controller can coexist during an update without duplicate route registrations. Configure the `strata` fields on the `llamacpp` plugin row for the controller’s `pythonPath`, `serverDirectory`, `configPath`, `baseUrl` and `port` for the installed AryaStrata engine. This machine uses `C:/AryaStrata` and port 8080. The selected startup configuration is `strata-qwen36s-ud-q4_k_xl.json`; changes saved to it by AryaStrata are used on restart.
+
+Stop and Restart require a process owned or adopted by the controller. Adoption matches the server entry point and configured configuration path; a process is never stopped merely because it occupies the engine port. Both `strata.exe` and `strata-poly.exe` are recognized. Changing model architecture is handled by AryaStrata, without a Qwen-only model list in this page.
+
+The page offers the Strata engine and, on the engine computer, the local NInfer engine serving the Qwen3.8 dense artifact. Ollama, llama.cpp and FreeToken have no page controls; their existing backend APIs remain available to preserve saved model-provider integrations. Changing this page does not install, delete or move engines, model files or chats.
+
+## NInfer (Qwen3.8 dense)
+
+The **NInfer** view controls the local engine that serves the pinned Qwen3.8 dense artifact (`qwen3.8-27b`). It uses the `ninfer` fields on the `llamacpp` plugin row exactly as before and adds no settings of its own.
+
+Start, stop and restart bind the model API to localhost. The engine loads for a while after Start, so the page reports `starting` until the model API answers. **NInfer tuning** is editable only while the engine is stopped, and **NInfer logs** reads the same owner-checked log tail. Tuning holds the context window, prefill chunk, host KV, MTP drafts, the **response output tokens** allowance, n-gram drafts and vision. The output allowance is shared by the engine and the Local model library chat model, so it must stay below the context window. The page never adopts a container or process it did not start.
+
+An engine started somewhere else is reported as **External** rather than left with dead controls. When the container is provably this installation's engine — the pinned image, this artifact, this port and its NInfer label — the page offers **Take over engine**, which stops that container and starts the engine it manages; while it is external the view still reads that container's own log, so the live figures keep working. Anything the page cannot identify is named with where it was started and is never touched.
+
+The view is a live operations dashboard. Model state, VRAM use and GPU load come from the host sensors; decode and prefill throughput, speculative-decoding acceptance and weight-loading progress come from the engine's own log. A failed start shows the engine's reason — usually not enough VRAM while Strata holds the GPU — with a button to stop Strata and retry. **Open NInfer dashboard** opens the engine's own web interface.
+
+**Connect your tools** states what a client needs and copies it: the OpenAI-compatible base URL, the chat-completions URL, the model name and the key the engine asks for (none on loopback), each with its own copy button, plus **Copy .env** for a ready environment block. A worked example switches between curl, Python and Node.js with the address and model already filled in. **Engine** lists the pinned artifact the page serves — context, response allowance, prefill chunk, host KV, MTP drafts, n-gram mode, vision and the runtime identity — so the numbers a client budgets against are on the same screen as the controls.
+
+Each engine is published to the harness with what it actually is: its real context window, its input modalities and its thinking levels, read from the engine's own settings. The response allowance stays a ceiling the engine enforces when a request asks for it — the model advertises an 8K per-request output default — so **Chat output limits** raises that for a session that needs longer answers.
+
+The switch appears only on the engine computer. A page that controls a paired computer keeps the Strata-only view, and the NInfer routes answer only loopback callers. Only one engine can hold the GPU at a time, so starting either engine first stops the other one — and any owned llama.cpp or FreeToken server or loaded Ollama model — then starts the requested engine. A stop that cannot be completed refuses the start instead of double-booking the GPU; an engine started outside this Host is reported and never killed.
+
+Chat model discovery, Benchmarks and model sharing with a paired computer are unchanged. They read the same `ninfer` configuration.
+
+## Browser access
+
+The web UI loads directly from the configured engine URL. A phone or another computer cannot access the host's `127.0.0.1`; the page explains this instead of embedding the wrong computer. Configure a reachable, authenticated AryaStrata address before using it remotely. An HTTPS AryaAI page cannot embed an HTTP engine; use the separate-tab link or an HTTPS engine address. The engine's own authentication remains in effect, and credentials are never added to its URL.
+
+A paired computer is more capable than a bare address: its own Host asks the paired address whether the engine's port answers there, and offers the interface only when it does. Publishing the engine port on the tailnet is enough — this machine uses `tailscale serve` for port 8080 — and the panel then embeds the engine UI instead of asking the user to walk to the other computer. When the port does not answer, the panel says so rather than showing a broken frame.
+
+## Another computer
+
+Install this plugin on both computers; 0.7.4 or newer is needed on both for the fixed pairing address and every engine model (model sharing needs 0.7.2, control alone 0.7.1). Control is set up with a short pairing code, the same way a phone is connected:
+
+1. On the engine computer open **AryaStrata → Let another computer control this engine** and choose **Create pairing code**.
+2. On the other computer open **AryaStrata → Control another computer**. Choose the engine computer from the list of machines on its tailnet, or type its Tailscale address, then type the eight-character code — the one it displays beside the addresses a second computer can reach it at. Letters and digits only; the dash is ignored.
+3. **Pair and control** exchanges the code once for a private token and starts controlling that engine. The code expires five minutes after it is created.
+
+The address the code offers is served by this plugin on a **fixed port (45900)** bound to the engine computer's tailnet address, and it forwards only the routes a paired computer uses: `/api/aryastrata/*` and `/api/local-llm/*`. Everything else on that address is a 404. The port matters because AryaAI chooses its own web port afresh at every launch — an address saved against that port stops working on the next restart, which looks like a network failure. With the fixed port the pairing survives restarts. Set `strata.pairPort` to use a different port, or `0` to turn the relay off (the offer then names the page's own port again). Set `strata.pairHost` when the tailnet address is not the one to bind. The first time it listens, Windows may ask whether to allow the app to accept connections — allow it for the tailnet, not for public networks.
+
+The paired computer appears under **Paired computers** on the engine computer, where it can be unpaired; unpairing revokes its token immediately. Pairing does not need a secret pasted by hand, and no token is shown on screen. **Use this computer** points the page back at the engine it runs itself.
+
+A panel that has a `strata.controlToken` on its `llamacpp` row still accepts that token, which is what an older installation uses:
+
+```yaml
+- id: llamacpp
+  config:
+    strata:
+      controlToken: a long random value
+```
+
+Restart AryaAI after editing it — the row is read at startup, and a page reload does not reload host code. A computer with no token and no paired computer keeps answering only itself, which is the safe default; the page says so rather than letting a connection fail as a 401. Under **Control another computer → Use a control token instead**, the same address and token can be entered directly.
+
+Start, stop, restart, the engine snapshot and logs are then answered by the engine computer, and the page names the computer it is controlling. The same code also shares the engine's models: every installed model is offered, and the paired computer lists them all in AryaAI's model picker (provider **Remote Local LLM**) with their real context windows. One code, one token, control and models together; revoking the paired computer ends both.
+
+An engine serves one model at a time but can switch: choosing a model the engine has not loaded asks it to switch (`POST /api/models/load`) before the request is sent, so chat moves between models without visiting the Control Center. The engine finishes the request it is running first, and refuses with the reason when that takes longer than its switch window. Models the engine reports as unusable are left out rather than offered and then failing.
+
+The models are also listed in the engine computer's own **Local model library**, so the host can chat with its engine without a separate provider row.
+
+The engine's own web interface still listens on the engine computer, so it is opened there rather than embedded when its port is not reachable.
+
+The hop is server to server: the page stays on its own machine's origin and the token never reaches the browser. Choosing a computer to pair with is local to that computer, and redeeming a code needs the code itself; nothing else changes which computer a page controls. Plain `http` is accepted only for loopback and Tailscale addresses, where the transport is already encrypted; any other address must be `https`. The status and control routes demand the token from every caller that is not on the engine computer, and an origin the engine computer never named is refused outright.
+
+## Validation
+
+```text
+npm run typecheck
+npm run build
+npm test
+node tests/aryastrata-ui.mjs
+```
+
+The browser test covers lifecycle controls, desktop/mobile layouts, an embedded web UI and errors retaining the current UI. To exercise a real local engine, set `ARYA_STRATA_LIVE=1` before running that test. This explicitly stops, starts and restarts the configured engine; run it only when no inference request is active. The live test loads the built Control Center package itself.
+
+[Legacy backend reference](LEGACY-CONTROL-CENTER.md) describes retained compatibility APIs, not the current page.
+
+## Chat output limits
+
+Open **AryaStrata → Chat output limits**, choose a configured local model, adjust **Output tokens per response**, and save. The number includes thinking, tool arguments and the final answer. Changes apply to subsequent requests. The editor supports values from 1,024 tokens to below the configured context window; input and output still share that context. Saving preserves other model settings. The desktop application can embed loopback engines through its dsh-app origin as well as a localhost browser.
+
+## Updating from the two-package release
+
+Install or update only `dsh-local-llm` 0.7.1 or newer on both computers in a remote-control setup. The old `dsh-strata` package may be uninstalled; its source and previous archives are retained for older installations. If you customized its controller row, move those configuration values into the `strata` object on the Control Center’s `llamacpp` row before removing it. The retired `dsh-strata-agent` preset is unrelated to engine control and is not included. Model files, chat history and saved model-provider settings are preserved.

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+- insert:
+    - id: llamacpp
+      name: '@aryacode/dsh-local-llm'
+      config: {}

package/icon.svg

@@ -0,0 +1,11 @@
+<svg width="36" height="36" viewBox="0 0 36 36" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <linearGradient id="localllm" x1="6" y1="7" x2="30" y2="29" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#8AD0FF" />
+      <stop offset="1" stop-color="#3D8BFF" />
+    </linearGradient>
+  </defs>
+  <rect x="9" y="9" width="18" height="18" rx="3" fill="url(#localllm)" />
+  <rect x="13.5" y="13.5" width="9" height="9" rx="1.6" fill="#FFFFFF" />
+  <path d="M13 4.5V8M18 4.5V8M23 4.5V8M13 28V31.5M18 28V31.5M23 28V31.5M4.5 13H8M4.5 18H8M4.5 23H8M28 13H31.5M28 18H31.5M28 23H31.5" stroke="#3D8BFF" stroke-width="2" stroke-linecap="round" />
+</svg>