qriton 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Marius Dima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,372 @@
+# Qriton CLI
+
+Qriton CLI is the terminal coding agent. It runs on infrastructure you control. Local models, hosted APIs, and the session record stay in one place: the conversation, the tools, and the memory move with the work, not with the provider.
+
+```
+qriton
+```
+
+## First session
+
+Install [Node](https://nodejs.org) 22.16 or later on the 22.x line, or Node 24. Install [Ollama](https://ollama.com) and leave it running.
+
+```bash
+npm install -g qriton
+qriton pull qwen3.5:4b
+qriton
+```
+
+`qriton` starts on `qwen3.5:4b`. `qriton --light` uses that model for one bounded session: an 8K context, thinking disabled, and keyword memory. If the pull or the model does not start, run `qriton doctor`.
+
+From the project directory, ask for a change. Qriton CLI shows the edit and waits.
+
+```text
+Approval · File change
+  - # qriton
+  + # Qriton
+
+  [y approve] · n reject · a allow kind
+```
+
+`y` writes the file. `n` leaves it unchanged. Nothing is written before you answer.
+
+With this local model, the prompt and the files Qriton CLI reads stay on this machine. Selecting Grok, Claude, or OpenAI sends that context to the provider. The commands are below, after the description of the product.
+
+## What it is for
+
+Qriton CLI keeps the evidence of a coding session attached to the session. You can change the model, resume the work, and inspect what was remembered.
+
+**Local execution.** Models run through [Ollama](https://ollama.com) on your machine. A bare model name selects a local model. `qriton pull` downloads it. `qriton --light` runs a bounded session: 8K context, thinking disabled, keyword memory.
+
+**Any model API, in the same session.** A prefix selects xAI, Anthropic, or OpenAI. `OPENAI_BASE_URL` selects an OpenAI-compatible endpoint, including OpenRouter, Groq, vLLM, and LM Studio. `/model` changes the model during a task. The transcript, approvals, and memory remain.
+
+**Memory with a history.** Facts are stored as a graph: nodes, edges, revisions, and full-text search. A repeated fact reinforces the current one. A corrected fact keeps the previous wording. A fact that no longer applies can be removed. A pinned fact is retained. The next session recalls from that record.
+
+**Hopfield recall.** `qriton pull bge-m3` installs the embedding model. With embeddings enabled, recall also reads the query against an energy landscape. A low-energy query matches a known basin. A high-energy query is new. A query between two basins — eureka — returns both. `/memory probe` compares ordinary recall with that reading. Keyword and graph recall remain available without embeddings.
+
+**HLM.** The [HLM workbench](docs/hlm.md) keeps a base model's weights frozen and applies a reversible memory overlay: preview, compare the next token, apply, evaluate, restore. The operation is on the local model. It does not replace the model conducting the coding session.
+
+**Energy Language.** The [Energy Language workbench](docs/energy.md) is programmable memory for a supported Hopfield checkpoint. Edits are staged, evaluated, and restored from bounded scripts. The source checkpoint is preserved.
+
+**Research with sources.** `research` queries several angles, reads the selected pages, and returns the passages that address the question, with numbered sources.
+
+**A session you can resume.** `qriton --continue` restores the latest session in this directory. `/sessions` lists them. See [session recovery](docs/session-recovery.md). `qriton capabilities` reports what is installed, without loading a model.
+
+The runtime adds the terminal interface, provider SDKs, Hopfield analysis, and controlled HTTP.
+
+## Where it fits
+
+Qriton CLI is for work that should stay on infrastructure you control, with the model treated as something you can switch and, for HLM and Energy Language, inspect.
+
+| | Qriton CLI | Claude Code | Codex CLI | Aider | Cursor |
+|---|---|---|---|---|---|
+| Form | Terminal | Terminal | Terminal | Terminal | IDE |
+| Model | On your machine through Ollama, or xAI, Anthropic, OpenAI, and any OpenAI-compatible API | Claude | OpenAI | On your machine, or an API you select | Selected hosted models in the editor |
+| One session across models | Yes. `/model` keeps the transcript, approvals, and memory | Within Claude | Within OpenAI | Yes | Yes |
+| What is retained | A graph of facts, with revisions, plus the session | Instructions and session notes | Project instructions | The repository, through git | The codebase in the editor |
+| The model itself | HLM can apply a reversible memory overlay. Energy Language can edit a Hopfield checkpoint | The coding model is the product | The coding model is the product | The coding model is the product | The coding model is the product |
+| Choose it for | A local session, a record of what was decided, and direct operations on a local model | Claude as the coding system | Codex in the terminal | Git-centred pairing with a model you choose | An editor built around the agent |
+
+The table describes the shape of each product. It is not a quality ranking.
+
+## Another model
+
+The first session stays on this machine. To use another provider in that same session:
+
+```bash
+qriton auth xai                 # https://console.x.ai
+qriton --model grok-4.6
+qriton --model grok-build-0.1
+
+qriton auth anthropic
+qriton --model anthropic/claude-opus-5
+
+qriton auth openai
+qriton --model openai/gpt-5-mini
+```
+
+`qriton auth` stores a key in the macOS Keychain, libsecret, or a private file on this machine. The same names work as `XAI_API_KEY`, `ANTHROPIC_API_KEY`, and `OPENAI_API_KEY`. An OpenAI-compatible server needs no extra adapter:
+
+```bash
+export OPENAI_BASE_URL=https://openrouter.ai/api/v1   # also Groq, vLLM, LM Studio
+```
+
+Set `network.allowHostedFallback` in user configuration when a hosted model should be available alongside Ollama. A managed machine can run shell, Git, and Python through the container profile in the [deployment guide](docs/production-operations.md).
+
+Check everything is wired up:
+
+```bash
+qriton doctor
+```
+
+## Use
+
+```bash
+qriton                              # interactive
+qriton "why does the build fail"    # interactive, with a first prompt
+qriton -p "list the exported types" # answer once, print, exit
+qriton -p --mode auto-edit "fix the typo" # allow file edits without a prompt
+qriton --plan "how would I add auth" # read-only investigation
+qriton -C ~/code/other-project      # work somewhere else
+qriton --continue                   # resume the latest session here
+qriton resume                       # same
+qriton --image shot.png "what is wrong here"
+```
+
+### Approval modes
+
+Writes and shell commands are confirmed before they run. Use `/auto on` to run them without approval prompts for this session, and `/auto off` to restore confirmations. `/auto` toggles, and `Shift+Tab` cycles modes only when the composer is empty and idle. In an open list it moves to the previous choice. The footer always shows the current mode and auto-run status.
+
+[Network policy](docs/network-policy.md) can limit destinations to this machine or to an exact list of origins. A restricted profile runs shell, Git, and Python through the [container profile](docs/production-operations.md).
+
+You can also use `/mode` or a startup flag:
+
+| Mode | Files | Shell |
+|---|---|---|
+| `suggest` (default) | confirm | confirm |
+| `auto-edit` | apply | confirm |
+| `full-auto` (`--yolo`) | apply | run |
+| `plan` (`--plan`) | blocked | blocked |
+
+At an approval prompt: `y` approve, `a` always allow that kind, `n` reject, `v` expand the preview. Or use `Tab`/`Shift+Tab` or `←`/`→` to select a bracketed choice and `Enter` to confirm it. The initial selection is approve once; `Esc` always rejects. Use `↑`/`↓` or `Page Up`/`Page Down` to inspect long previews. The input draft is preserved while the approval owns the keyboard.
+
+### Models
+
+`/models` opens a searchable list across the available backends. OpenAI coding models appear by newest family first; the current model is marked without being moved above newer choices. Audio, image, embedding and other specialized endpoints are excluded, and dated snapshots are hidden when a rolling alias is available. Type to filter, use arrows or `Tab`/`Shift+Tab` to move, then `Enter` to switch. Browsing does not warm or load a model; selection uses the normal model-switch flow. `Esc` returns to the draft. `/model <name>` also switches directly, keeping the transcript and memory:
+
+```
+/model grok-4.6
+/model grok-build-0.1
+/model anthropic/claude-opus-5
+/model openai/gpt-5.6-sol
+/model qwen2.5-coder:7b          bare names mean Ollama
+```
+
+A bare `claude-*`, `gpt-*`, or `grok-*` routes correctly without the prefix. Ollama names containing slashes, like `hf.co/user/repo`, are left alone.
+
+A practical division of work is to inspect with a local model, switch to a hosted model for the edit, and switch back. The session is unchanged.
+
+OpenAI reasoning models use the Responses API, including Codex and GPT-5.6 tool calls. Requests use `store: false`; encrypted reasoning continuity stays in the local session and is replayed only to the same endpoint and model. Custom OpenAI-compatible endpoints retain Chat Completions. `/models` lists what the configured account offers. See [OpenAI's migration guide](https://developers.openai.com/api/docs/guides/migrate-to-responses).
+
+### Ollama servers and local feedback
+
+`/servers` opens a choice between checking this computer and scanning the local network. `/servers local` checks `127.0.0.1:11434`; `/servers scan` checks up to 255 addresses on attached private IPv4 subnets, on port 11434, with eight probes at a time and short timeouts. Large subnets are limited to the surrounding /24. A scan can miss servers on other ports, other subnets, IPv6, or behind a firewall. Discovery checks version and model metadata only; it does not load models or send prompts. Use Escape to cancel.
+
+Choose a discovered server with Enter, or use `/server <url>`. Qriton verifies it and saves the Ollama address; `/models` shows models from that server with its address. The coding model stays as it is until you select one. A private IPv4 server you choose may use HTTP. Other remote services use HTTPS. To expose an Ollama server to your LAN, configure its bind address as described in the [Ollama FAQ](https://docs.ollama.com/faq#how-can-i-expose-ollama-on-my-network).
+
+`/feedback` opens a multiline feedback composer. Enter saves, Ctrl+J adds a line, and Escape cancels. `/feedback <text>` saves directly. Reports are private files under `~/.qriton/feedback/` (or `$QRITON_HOME/feedback/`), containing only what you type, the Qriton version, timestamp and report ID. Conversation history, credentials and workspace files are not attached. Feedback is separate from project memory and is never uploaded; no feedback API is configured.
+
+### Commands
+
+Type `/` to discover commands. `↑`/`↓` moves the highlighted suggestion, `Tab` fills it, and `Esc` closes suggestions without clearing the draft. `Enter` fills a partial command first; press it again to run the completed command. Common options are suggested too: try `/theme `, `/mode `, `/auto `, `/queue ` or `/auth `.
+
+`/sessions` opens a searchable list of conversations in the current workspace. Filter by title, model or ID; use arrows or `Tab`/`Shift+Tab` to navigate, `Enter` to resume, and `Esc` to return. The footer shows shortcuts for the active control. See [terminal interaction principles](docs/terminal-interaction.md) for the keyboard contract and current scope.
+
+| | |
+|---|---|
+| `/help` | commands and shortcuts |
+| `/theme light\|dark` | switch and save colors for a white or dark terminal background |
+| `/queue [pause\|resume\|clear]` | inspect, pause, resume, or cancel pending instructions |
+| `/model <name>` | switch chat model, any backend |
+| `/fast <name>` | switch the fast model (memory, compact) |
+| `/models` | browse, filter and select a chat model |
+| `/auth` | which API keys are stored |
+| `/usage` | token and cost log |
+| `/sessions` | browse, filter and resume saved conversations here |
+| `/save` | save the current conversation or retry a failed save |
+| `/resume [id]` | continue a saved session |
+| `/image <path>` | attach a screenshot to the next message |
+| `/pull <name>` | download a local model |
+| `/mode <mode>` | change approval mode |
+| `/auto [on\|off]` | toggle automatic writes and commands for this session |
+| `/policy` | inspect effective configuration, trust and managed limits |
+| `/memory` | graph stats and recent entries |
+| `/capabilities` | configured features, optional HLM installations and commands to try; no model load |
+| `/energy [command]` | inspect, preview, apply, evaluate and restore HLM checkpoint edits |
+| `/hlm [command]` | Qriton HF models, local completion, frozen/active comparison and reviewed factual-memory edits |
+| `/memory probe <query>` | compare plain and Hopfield recall without reinforcing memories |
+| `/recall <query>` | search memory |
+| `/remember <text>` | save a pinned memory yourself |
+| `/forget <id>` | drop a memory |
+| `/sweep` | forget everything that has faded |
+| `/unload` | free the memory local models are holding |
+| `/stats` | context use, tokens per second, active backends |
+| `/clear` | reset the conversation |
+
+The composer stays at the bottom of the terminal and grows up to six lines. Longer drafts scroll around the cursor. `Ctrl+J` inserts a newline, and a trailing `\` continues a line. `↑`/`↓` move within multiline drafts or walk prompt history on a single line. `Page Up`/`Page Down` scroll the conversation; reaching the bottom resumes following new output. `Esc` interrupts a running turn, and `Ctrl+C` twice exits. The interactive UI uses the alternate screen and restores your terminal on exit; saved sessions retain the conversation.
+
+Use `/theme light` on a white terminal background for dark body text and readable secondary text. The input uses a native blinking caret on supported terminals, with no application animation timer. The terminal controls its blink timing and any fade effect.
+
+You can type an addition or correction while Qriton works and press **Enter**. The pending instruction appears above the composer and joins the current task at the next safe step. Actions that have not started are deferred until the model has considered the update; a running tool finishes first. **Esc** interrupts immediately and pauses pending input. `/queue` shows pending instructions, `/queue pause` holds them, `/queue resume` continues, and `/queue clear` cancels them. Failed or interrupted turns pause remaining requests. If the current operation cannot receive updates, pending requests run afterward, one at a time. `/exit` also works during a running turn. Approval dialogs retain their decision keys, and settings commands wait until the agent is idle with no pending requests.
+
+The pending queue holds up to ten requests for the current session; it is not restored after exit. Once an update is added to the task, it becomes part of the normal saved conversation. A full queue leaves your draft intact.
+
+When a model ends an execution request with a routine chat question such as “approve these edits to continue,” Qriton makes one recovery attempt directing it to concrete tool calls. The UI shows this handoff. The reminder grants no permission and leaves the selected approval mode unchanged. Missing choices, credentials, plan-only requests and consequential actions still need the appropriate user input; rejected tools are never unblocked by this recovery. A repeated stall reports unfinished work instead of looping or claiming completion.
+
+Unattended runs reject actions that need approval in `suggest` mode. Choose `--mode auto-edit` for file edits or `--mode full-auto` for explicitly unattended shell work. `--plan` blocks writes even if a model emits an unadvertised tool call. Exit codes are 0 for completion, 3 for rejected actions, 130 for interruption, and 1 for provider errors, truncation, a repeated approval stall, or an exhausted step limit.
+
+Resuming a session restores its model unless `--model` overrides it. The current invocation's approval mode remains in force. `-C` selects both the workspace and its project configuration.
+
+## HLM and Energy Language
+
+Both are optional and run locally. Python and PyTorch are installed separately. The model conducting the coding session is unchanged.
+
+HLM keeps a published base model frozen and stages a memory overlay. `qriton hlm catalog` lists the releases. The [walkthrough](docs/hlm.md) covers setup.
+
+```sh
+qriton hlm compare hlm5-1b "The capital of Veldoria is"
+qriton hlm preview hlm5-1b examples/hlm/memorize.hlm examples/hlm/controls.json
+qriton hlm apply <proposal-id>
+qriton hlm evaluate <proposal-id>
+qriton hlm restore <proposal-id>
+```
+
+Energy Language does the reversible edit for a supported Hopfield checkpoint, using a bounded script. The [guide](docs/energy.md) covers the runtime and the evaluation suite. Apply and restore ask for approval.
+
+```sh
+qriton energy doctor
+qriton energy inspect models/model.pt
+qriton energy preview models/model.pt examples/energy/edit.hlm
+qriton energy apply <proposal-id>
+qriton energy evaluate <proposal-id>
+qriton energy restore <proposal-id>
+```
+
+## Tools
+
+| Tool | What it does |
+|---|---|
+| `read_file`, `write_file`, `edit_file` | read, create, and patch files |
+| `list_dir`, `glob`, `grep` | explore and search the workspace |
+| `shell` | run commands, with a denylist and a timeout |
+| `git_status`, `git_diff`, `git_commit` | inspect and commit; commits need an explicit file list |
+| `web_search`, `fetch_url` | find pages, read one page |
+| `research` | search, crawl, rank, and cite |
+| `remember`, `recall` | save and retrieve memories |
+| `update_memory`, `forget` | correct or drop a memory |
+| `link_memory`, `memory_graph` | connect memories, inspect connections |
+| `plan` | track a multi-step task |
+
+Read-only tools run in parallel and never prompt. Everything else is serialised behind approval.
+
+## Configuration
+
+`~/.qriton/config.json`, or `.qriton/config.json` in a project to override per workspace. Project configuration requires an explicit grant: run `qriton trust show`, review the file, then `qriton trust grant <fingerprint>`. Changes require a new grant. `qriton doctor policy` inspects effective settings and their origins offline; `/policy` shows the active session. See [workspace configuration trust](docs/workspace-trust.md).
+
+`qriton` already starts on `qwen3.5:4b`. Save this file to keep an 8K context and embeddings for later sessions. `qriton --light` still applies the bounded session for a single run, with keyword memory for that run. The `model` field also accepts `grok-4.6`, `anthropic/claude-opus-5`, `openai/gpt-5-mini`, or any model served through `OPENAI_BASE_URL`.
+
+```jsonc
+{
+  "model": "qwen3.5:4b",
+  "fastModel": "qwen3.5:4b",      // summarising, memory extraction
+  "embedModel": "bge-m3:latest",
+  "keepAlive": "30s",             // how long Ollama retains the model
+  "releaseOnExit": true,          // release the model when Qriton exits
+  "contextTokens": 8192,
+  "reasoning": "off",
+  "maxOutputTokens": 1024,        // ceiling per step
+  "maxSteps": 8,
+  "approvalMode": "suggest",
+  "search": { "backend": "auto", "fetchTopN": 4 },
+  "memory": { "seedK": 8, "hops": 1, "recallLimit": 10, "autoCapture": true, "embeddings": true, "hopfield": true }
+}
+```
+
+`qriton pull bge-m3` fills `embedModel`. With embeddings on, `/memory probe` can compare plain recall and the Hopfield reading.
+
+### Environment
+
+| | |
+|---|---|
+| `OLLAMA_HOST` | Ollama server, default `http://127.0.0.1:11434` |
+| `QRITON_MODEL` | override the chat model |
+| `XAI_API_KEY` | use Grok models |
+| `ANTHROPIC_API_KEY` | use Claude models |
+| `OPENAI_API_KEY` | use OpenAI models |
+| `OPENAI_BASE_URL` | any OpenAI-compatible server |
+| `TAVILY_API_KEY` / `BRAVE_API_KEY` | better search ranking |
+| `SEARXNG_URL` | use your own SearXNG instance |
+| `QRITON_DEBUG=1` | debug log at `~/.qriton/debug.log` |
+
+### Project instructions
+
+Drop a `QRITON.md` in the repo root and it is loaded into every session. `AGENTS.md` and `CLAUDE.md` are picked up too.
+
+## How it fits together
+
+```
+cli.tsx ──► Agent ──► ProviderRegistry ──► Ollama    (local, streaming)
+              │                        ├─► xAI       (Grok)
+              │                        ├─► Anthropic (official SDK)
+              │                        └─► OpenAI    (official SDK, or any compatible API)
+              │
+              ├─► ToolRegistry ──► fs · shell · web · memory · plan
+              │
+              ├─► MemoryStore   ──► nodes, edges, revisions, full-text search
+              │                     vectors held in memory, cosine ranked
+              │
+              ├─► Embedder      ──► bge-m3 through the configured Ollama server
+              │
+              ├─► HLM           ──► frozen base model, reversible memory overlay
+              │
+              └─► Energy        ──► reversible edits to a Hopfield checkpoint
+```
+
+Every provider normalises to one event stream, so the agent loop never learns which backend it is talking to. The translation each one needs is real, though: Anthropic takes the system prompt as a top-level parameter and requires all parallel tool results in a single user message, while OpenAI takes one message per result with a `tool_call_id`.
+
+The system prompt is built once per session and never rewritten. Ollama caches the prompt prefix between requests, and changing the system message would force a full reprocess of several thousand tokens on every step. Per-turn content such as recalled memories goes into the user message instead, so history only ever grows and the cache keeps paying off.
+
+When the transcript passes 75% of the context window, the older half is summarised by the fast model and recent turns are kept verbatim.
+
+Models without native tool support use fenced `tool` blocks.
+
+## Speed
+
+Most of the elapsed time is model inference. The first turn sends roughly a 3,600-token prefix, covering the system prompt and tool schemas. Later turns send only the new tokens. Two measurements describe the result:
+
+| | |
+|---|---|
+| prompt processing | how long before the first token appears |
+| token generation | how fast the answer streams |
+
+`/stats` shows tokens per second after each turn. `--light` shortens local turns, and `maxOutputTokens` caps each step.
+
+### Context budget
+
+Qriton compacts automatically before the next request exceeds its estimated input budget. It keeps complete tool exchanges that fit, preserves the newest user instructions and attachments, and carries a bounded record of the task plan into the summary. Large file reads no longer force the last eight messages to stay in context. Long tool results show an explicit shortening notice; request narrower file ranges or filtered command output to recover omitted detail.
+
+The summary request uses the fast model's context window. Compaction leaves the system prompt stable and does not change approval mode. `/compact` requests it manually, and `/stats` shows estimated usage.
+
+### Memory pressure
+
+A local model resides in memory alongside the other processes on the machine:
+
+- The model is **released when qriton exits**, rather than staying pinned for the rest of its keep-alive. Turn this off with `"releaseOnExit": false`.
+- `keepAlive` defaults to 10 minutes, so a resumed turn does not reload the model immediately.
+- The embedding model gets its own 2-minute keep-alive, because it loads in under a second.
+- Switching models with `/model` releases the one you left.
+- `/unload` releases resident models without ending the session.
+
+`--light` uses an 8K context, four CPU inference threads, 1,024 output tokens per step, eight steps per turn and thinking off. Main and fast tasks use the same model. Keyword and graph recall stay available, and chat residency expires after 30 seconds idle.
+
+A hosted model leaves local inference unloaded. With `--model openai/gpt-5-mini` or `--model anthropic/claude-opus-5`, the only local model left is the embedder, and only while it is working.
+
+The `reasoning` setting chooses whether a model's scratchpad is shown in its own channel or left inline. `"on"` keeps the scratchpad separate from the reply.
+
+## Development
+
+Local [Shield scanning](docs/shield.md) checks retrieved content and withholds recognized credentials. `qriton shield status` and `qriton shield scan SKILL.md` run offline.
+
+```bash
+npm run dev        # esbuild watch
+npm test           # unit tests
+npm run typecheck
+```
+
+`qriton memory reembed` refreshes stored vectors with the current embedder and keeps each fact's history.
+
+## License
+
+MIT
+
+The [deployment guide](docs/production-operations.md) covers installation, the container profile, memory authorization, backup and restore, and rollback.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,201 @@
+# Bundled Qriton Shield
+
+The CLI bundles local scanner code from @qriton/shield 3.3.0 (Apache-2.0). The integration calls its standalone scanners and adapts their output; it does not modify the upstream package.
+
+Qriton Shield
+Copyright 2024-2026 Qriton Technologies
+
+This product includes software developed by Qriton Technologies
+(https://qriton.com).
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024-2026 Qriton Technologies
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/containers/runner.Dockerfile

@@ -0,0 +1,14 @@
+FROM node:24-trixie-slim@sha256:8ec5d7557396cfe32d21c3f9c13072355ceab22b584578ca4bb28af31120cffe
+RUN apt-get update && apt-get install -y --no-install-recommends git python3 coreutils ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+RUN npm install --global --ignore-scripts --no-audit --no-fund npm@12.0.2
+# The published CLI's development-only dependencies include unavailable packages.
+# They are not part of this runtime toolchain or its dependency patch operation.
+RUN node -e 'const fs=require("node:fs"),p="/usr/local/lib/node_modules/npm/package.json",v=JSON.parse(fs.readFileSync(p));delete v.devDependencies;fs.writeFileSync(p,JSON.stringify(v,null,2)+"\n")' \
+    && npm install --prefix /usr/local/lib/node_modules/npm --omit=dev --ignore-scripts --no-audit --no-fund --save-exact \
+       brace-expansion@5.0.9 ip-address@10.3.1 tar@7.5.21 undici@6.28.0 \
+    && npm cache clean --force
+# npm 12.0.2 still bundles the vulnerable revisions; keep these compatible
+# dependency fixes pinned until a reviewed upstream npm release includes them.
+# Configure the resulting immutable image ID/digest, never this build's mutable tag.
+WORKDIR /workspace