Release notes 0.2.7: update, tray and speed lines confirmed on the release packages; Strix Halo guide names the prompt used for the 4K row

Version 0.2.7: Terminal and app 0.2.7, engine and Control 0.1.52 (every Qwen and DeepSeek package, Metal included; both engines changed since 0.2.6)
Same 15 files as the 0.2.6 bump (issue template, AGENTS.md, CMakeLists.txt 0.1.52, desktop and host package files, Cargo.toml and the strata-desktop entry in Cargo.lock, SettingsUpdates comment, qa1-storage test, metal 0.1.52-metal, build_hip_linux.sh PKGVER 0.1.52, strata_cli PRODUCT_VERSION, the two version tests), plus the Strata-0.2.7-<file> names in the md files.
2026-11-07 14:21:06 -10:00 · 2026-10-27 14:54:33 +01:00 · 2026-10-27 09:13:22 +01:00 · 2026-10-27 09:13:21 +01:00 · 2026-10-27 09:10:53 +01:00 · 2026-10-27 09:10:53 +01:00
2169 changed files with 397654 additions and 11155 deletions
@@ -17,6 +17,11 @@ __pycache__/
 /mtp/
 /models/
 /Strata-data/
+# the folders docker/entrypoint.sh creates in a mounted data/ (a link to llama.cpp, the models, the keys): never part of a build (#3644)
+/data/install/
+/data/state/
+/data/home/
+/data/Strata-data/
 third_party/llama.cpp/
 third_party/*.zip
 *.done
@@ -4,9 +4,27 @@ bench/prompts/** -text
 # launchers keep their platform line endings wherever the repository is cloned
 *.sh text eol=lf
 *.bat text eol=crlf
+*.cmd text eol=crlf
+*.ps1 text eol=crlf
+bin/strata text eol=lf

 # copies of real packs' native_experts.txt, parsed byte for byte by tests/core/expert_layout_test.cpp
 tests/data/native_experts/** -text

 # the quant yardstick's text set: tokenized byte for byte (set.ids.json), never convert its line endings
 data/quant_quality/** -text
+
+# the license text is shipped and checked as LF text on every checkout
+LICENSE text eol=lf
+
+# container scripts run in Linux: always LF
+docker/*.sh text eol=lf
+Dockerfile text eol=lf
+docker/Dockerfile text eol=lf
+docker/compose/* text eol=lf
+
+# Apple tools (codesign, plutil) read these: LF only, wherever the repository is cloned
+*.plist text eol=lf
+
+# vendored KaTeX (serve/web/vendor): the files are hashed byte for byte (PROVENANCE.json), never convert their line endings.
+serve/web/vendor/** -text
@@ -0,0 +1,26 @@
+name: Benchmark
+description: Share measurements from your machine, or report a problem with the benchmark tools
+title: "[Benchmark] "
+labels: ["benchmark"]
+body:
+  - type: markdown
+    value: |
+      The title must start with **[Benchmark]**. Keep it, and add the GPU and model after it.
+
+      To share a full report, follow the [community benchmark guide](https://github.com/Niko1221/Strata/blob/main/docs/COMMUNITY_BENCHMARKS.md) and open a results-only pull request. The standard protocol is a [draft](https://github.com/Niko1221/Strata/blob/main/docs/BENCHMARK_PROTOCOL.md); existing tools do not implement it yet. Include poor results and failed requests.
+  - type: textarea
+    id: what
+    attributes:
+      label: What did you measure, or what went wrong
+      description: Hardware (GPU and VRAM, CPU, RAM, OS), Strata version, model and quantization, the exact command, and the numbers. Paste the report or link the pull request.
+    validations:
+      required: true
+  - type: dropdown
+    id: reproduction-status
+    attributes:
+      label: Reproduction status
+      options:
+        - Measured locally
+        - Unconfirmed (I did not run it)
+    validations:
+      required: true
@@ -1,37 +1,101 @@
 name: Bug report
 description: Something in Strata doesn't work as documented
-title: "[Bug]: "
+title: "[Area] "
 labels: ["bug"]
 body:
  - type: markdown
    value: |
-      Thanks for the report.
+      Thanks for the report. Please read [CONTRIBUTING.md](https://github.com/Niko1221/Strata/blob/main/CONTRIBUTING.md) first.

-      Please search the [open issues](https://github.com/Niko1221/Strata/issues?q=is%3Aissue+state%3Aopen) first — this may already be tracked.
+      Search the [open and closed issues](https://github.com/Niko1221/Strata/issues?q=is%3Aissue) first: this may already be tracked, and new evidence belongs in that thread.
+
+      Write only what you saw. Do not guess at steps, errors, hardware or severity.
+
+      **The title must start with its area:** [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other]. Choose the same one below.
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      description: Start the issue title with the same area in square brackets, for example "[Engine] decode stops after 2 minutes". Pick Other if none fits.
+      options:
+        - "[Engine]  (speed, kernels, models, the server and API)"
+        - "[GUI]  (the desktop app)"
+        - "[TUI]  (the Terminal: strata launch, connect, monitor)"
+        - "[Benchmark]  (measurements and reports)"
+        - "[Docs]  (documentation)"
+        - "[Other]  (anything else, including setup and installation)"
+    validations:
+      required: true
+  - type: dropdown
+    id: how
+    attributes:
+      label: Desktop app, Terminal or source?
+      options:
+        - Desktop app (Windows, Linux or Mac)
+        - Terminal (the `strata` command)
+        - Source (START-HERE.bat, setup.sh or a build)
+        - Docker
+        - Other
+    validations:
+      required: true
  - type: textarea
    id: what
    attributes:
      label: What happened
-      description: What you did, what you got, and what you expected instead. Paste the exact error text if there is one. If there's a set of steps or commands that reproduces it, put them here too.
+      description: What you did, what you got, and what you expected instead. Paste the exact error text if there is one.
+    validations:
+      required: true
+  - type: textarea
+    id: reproduce
+    attributes:
+      label: Smallest steps or command that reproduce it
+      description: The shortest list of steps that shows the problem. If you cannot make it happen again, say so here.
+    validations:
+      required: false
+  - type: dropdown
+    id: reproduction-status
+    attributes:
+      label: Reproduction status
+      options:
+        - Reproduced locally
+        - Unconfirmed static analysis (I read code or ran a scanner; I did not see it fail)
+    validations:
+      required: true
+  - type: input
+    id: version
+    attributes:
+      label: Strata version
+      description: "In the app: Settings > About. In the Terminal: `strata --version`. From source: the About tab of the web page, or `engine` in `GET /v1/status`, or the git commit."
+      placeholder: "Strata 0.2.7 · engine 0.1.52"
    validations:
      required: true
  - type: input
    id: hardware
    attributes:
-      label: Strata version, GPU, OS
-      description: The engine version is on the About tab, or in `GET /v1/status` under `engine`.
-      placeholder: "0.1.31 · RTX 5070 12GB · Windows 11"
+      label: Graphics card, memory and system
+      description: The card and its VRAM, the RAM of the PC, and the operating system.
+      placeholder: "RTX 5070 12 GB · 64 GB RAM · Windows 11"
    validations:
      required: true
+  - type: input
+    id: model
+    attributes:
+      label: Model, size and settings
+      description: The model and size you started, the context, and whether pictures were on. Write what is relevant.
+      placeholder: "Qwen3.8-Flash-Next IQ2_XS · 128K context · pictures on"
+    validations:
+      required: false
  - type: textarea
    id: log
    attributes:
-      label: Engine log
-      description: Drag in `strata-<model>.log` from your Strata folder. Drag and drop works directly into this box.
+      label: Logs
+      description: |
+        The app: Settings > Engine > Diagnostics > View logs > Save logs, then drag the file in. The Terminal: paste the output of `strata doctor`. From source: drag in `strata-<model>.log` from your Strata folder.
+        Remove API keys, passwords and private text first.
    validations:
      required: false
  - type: markdown
    value: |
      A couple of extras that help a lot:

-      - Check the [troubleshooting table](https://github.com/Niko1221/Strata/blob/main/docs/DETAILS.md#troubleshooting) first, many reports are already solved there.
+      - Check the [troubleshooting page](https://github.com/Niko1221/Strata/blob/main/docs/TROUBLESHOOTING.md) first, many reports are already solved there.
@@ -1,5 +1,5 @@
 blank_issues_enabled: true
 contact_links:
  - name: Troubleshooting and known issues
-    url: https://github.com/Niko1221/Strata/blob/main/docs/DETAILS.md#troubleshooting
+    url: https://github.com/Niko1221/Strata/blob/main/docs/TROUBLESHOOTING.md
    about: Symptom-to-fix table for crashes, out of memory, hangs, and port problems.
@@ -1,18 +1,41 @@
 name: Feature request
 description: Suggest something new or an improvement
-title: "[Feature]: "
+title: "[Area] "
 labels: ["enhancement"]
 body:
  - type: markdown
    value: |
-      Explain what you want in plain language.
+      Explain what you want in plain language. For a large feature, a change to a default or a refactor, please agree the scope here first. Read [CONTRIBUTING.md](https://github.com/Niko1221/Strata/blob/main/CONTRIBUTING.md).
+
+      **The title must start with its area:** [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other]. Choose the same one below.
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      description: Start the issue title with the same area in square brackets, for example "[Engine] decode stops after 2 minutes". Pick Other if none fits.
+      options:
+        - "[Engine]  (speed, kernels, models, the server and API)"
+        - "[GUI]  (the desktop app)"
+        - "[TUI]  (the Terminal: strata launch, connect, monitor)"
+        - "[Benchmark]  (measurements and reports)"
+        - "[Docs]  (documentation)"
+        - "[Other]  (anything else, including setup and installation)"
+    validations:
+      required: true
  - type: textarea
    id: idea
    attributes:
      label: What do you want to do?
-      description: Describe the goal rather than the implementation. If there's a workaround you use today, mention it.
+      description: Describe the goal rather than the implementation. Say who needs it and why.
    validations:
      required: true
+  - type: textarea
+    id: workaround
+    attributes:
+      label: What do you do today instead?
+      description: The workaround you use now, if there is one.
+    validations:
+      required: false
  - type: markdown
    value: |
-      All of this counts: model and architecture support, the server and API, the web app, multi-GPU and layer split, images and vision, MCP servers, setup and installation, and performance.
+      All of this counts: model and architecture support, the server and API, the app and the Terminal, multi-GPU and layer split, images and vision, MCP servers, setup and installation, and performance.
@@ -1,11 +1,27 @@
 name: Question
 description: Ask how to use Strata, or share a result
-title: "Question: "
+title: "[Area] "
 labels: ["question"]
 body:
  - type: markdown
    value: |
-      Not sure how to do something, or want to share numbers from your machine? Ask here.
+      Not sure how to do something, or want to share numbers from your machine? Ask here. To share a full benchmark, see [CONTRIBUTING.md](https://github.com/Niko1221/Strata/blob/main/CONTRIBUTING.md#share-a-benchmark).
+
+      **The title must start with its area:** [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other]. Choose the same one below.
+  - type: dropdown
+    id: area
+    attributes:
+      label: Area
+      description: Start the issue title with the same area in square brackets, for example "[Engine] decode stops after 2 minutes". Pick Other if none fits.
+      options:
+        - "[Engine]  (speed, kernels, models, the server and API)"
+        - "[GUI]  (the desktop app)"
+        - "[TUI]  (the Terminal: strata launch, connect, monitor)"
+        - "[Benchmark]  (measurements and reports)"
+        - "[Docs]  (documentation)"
+        - "[Other]  (anything else, including setup and installation)"
+    validations:
+      required: true
  - type: textarea
    id: question
    attributes:
@@ -13,10 +29,17 @@ body:
      description: What you're trying to do. Include your version, GPU, and OS if it affects the answer.
    validations:
      required: true
+  - type: textarea
+    id: tried
+    attributes:
+      label: What you tried
+      description: What you already did and where you got stuck.
+    validations:
+      required: false
  - type: textarea
    id: numbers
    attributes:
      label: Results (optional)
      description: Only if you ran a benchmark or measured speed. Model, quant, context, and the tok/s you get.
    validations:
-      required: false
+      required: false
@@ -1,12 +1,30 @@
-## Title
-<!-- If Applicable, reference the GitHub issue -->
-Issue: Resolves # 
+**The title must start with its area: [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other], for example "[Engine] fix decode stop on long prompts" or "[GUI] keep the model list after a tab switch".**

-## Summary
-<!-- Quick Summary of changes -->
+<!--
+Read CONTRIBUTING.md first. Lead with the problem and the result, not a file-by-file list.
+Placeholders below are not test results: replace them with what you observed, or write "none".
+-->

-## What changed
-<!-- Specifics on files changed, and what changes were made there -->
+## Problem and result
+<!-- What triggered this change. How it behaves before and after. -->

-## Extra Notes
-<!-- Any extra notes, delete if there are none -->
+## Related discussion
+<!-- The issue URL and the maintainer's agreement on scope, when the change needs one (features, refactors, defaults). Write "none" if not applicable. -->
+
+## Approach
+<!-- Why this fix. Compatibility effects. Keep unrelated cleanup out of the PR. -->
+
+## Validation
+<!-- Exact commands, the revision and the environment tested, what you saw. Keep the three lists apart. -->
+
+**Passed:**
+<!-- command, revision/environment, observed result, log -->
+
+**Failed:**
+<!-- command and failure, or "none observed" -->
+
+**Not run:**
+<!-- check, why, and what stays unverified (for example CUDA, HIP, SYCL or Metal builds you could not do) -->
+
+## Limits
+<!-- Known limitations or remaining work. -->
@@ -0,0 +1,218 @@
+'use strict';
+// Format check for issues and pull requests (see CONTRIBUTING.md and .github/ISSUE_TEMPLATE/*.yml).
+// Pure functions only: no network, no filesystem. Used by intake.yml and reopen.yml through reset-bot.js.
+
+const AREAS = ['Engine', 'GUI', 'TUI', 'Benchmark', 'Docs', 'Other'];
+const TITLE_RE = new RegExp('^\\[(' + AREAS.join('|') + ')\\] \\S');
+const NO_ANSWER = /^(_no response_|none|n\/a|na|-|todo|tbd|\.|\?)$/i;
+const NOT_RUN_LABELS = /^\*\*(passed|failed|not run)\s*:?\*\*\s*:?/gim;
+
+// Version the reopened work must be tested on.
+const CURRENT_VERSION_RE = /\b0\.2\.\d+|0\.2\.0-beta/i;
+// Any version or commit.
+const ANY_VERSION_RE = /\bv?\d+\.\d+(\.\d+)*(-[a-z0-9.]+)?\b|\b[0-9a-f]{7,40}\b|\bcommit\b/i;
+const HARDWARE_RE = /\b(rtx|gtx|geforce|quadro|tesla|radeon|rx ?\d|instinct|arc|a\d{3,4}|b\d{2,3}|apple|m[1-5]( pro| max| ultra)?|nvidia|amd|intel|gpu|cpu|vram|\d+ ?gb|ram|windows|linux|ubuntu|debian|fedora|arch|macos|mac os|wsl)\b/i;
+const REVISION_RE = /0\.2\.\d|beta|\bmain\b|\b[0-9a-f]{7,40}\b/i;
+
+function stripComments(text) {
+  return String(text || '').replace(/<!--[\s\S]*?-->/g, '');
+}
+
+function hasAreaPrefix(title) {
+  return TITLE_RE.test(String(title || ''));
+}
+
+// Issue forms render as "### Label\n\nvalue". Returns { label: value } for those headings.
+function parseSections(body) {
+  const out = {};
+  let cur = null;
+  for (const line of stripComments(body).split(/\r?\n/)) {
+    const m = /^#{1,6}\s+(.+?)\s*#*\s*$/.exec(line);
+    if (m) {
+      cur = m[1].trim();
+      out[cur] = '';
+    } else if (cur !== null) {
+      out[cur] += line + '\n';
+    }
+  }
+  for (const k of Object.keys(out)) out[k] = out[k].trim();
+  return out;
+}
+
+function realText(value) {
+  const t = String(value || '').replace(NOT_RUN_LABELS, '').replace(/\s+/g, ' ').trim();
+  return NO_ANSWER.test(t) ? '' : t;
+}
+
+function findSection(sections, re) {
+  for (const k of Object.keys(sections)) if (re.test(k)) return { key: k, value: sections[k] };
+  return null;
+}
+
+// Required parts of each issue form: [display name, heading regex, minimum characters of real text].
+const FORMS = {
+  bug: {
+    detect: /what happened/i,
+    parts: [
+      ['Area', /^area$/i, 2],
+      ['Desktop app, Terminal or source?', /desktop app, terminal or source/i, 2],
+      ['What happened', /what happened/i, 20],
+      ['Reproduction status', /reproduction status/i, 2],
+      ['Strata version', /strata version/i, 3],
+      ['Graphics card, memory and system', /graphics card|memory and system/i, 3],
+    ],
+    needsCurrentVersion: 'Strata version',
+  },
+  feature: {
+    detect: /what do you want to do/i,
+    parts: [
+      ['Area', /^area$/i, 2],
+      ['What do you want to do?', /what do you want to do/i, 20],
+    ],
+  },
+  question: {
+    detect: /your question/i,
+    parts: [
+      ['Area', /^area$/i, 2],
+      ['Your question', /your question/i, 15],
+    ],
+  },
+  benchmark: {
+    detect: /what did you measure/i,
+    parts: [
+      ['What did you measure, or what went wrong', /what did you measure/i, 30],
+      ['Reproduction status', /reproduction status/i, 2],
+    ],
+    needsCurrentVersionInBody: true,
+  },
+};
+
+function checkIssue({ title, body, labels = [], mode = 'intake' }) {
+  const missing = [];
+  if (!hasAreaPrefix(title)) {
+    missing.push('Start the title with its area: [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other], then a short description. Example: "[Engine] decode stops after 2 minutes".');
+  }
+  const text = stripComments(body);
+  const sections = parseSections(text);
+  const labelSet = new Set(labels.map((l) => String(l).toLowerCase()));
+  const needCurrent = mode === 'reopen';
+
+  let formKey = null;
+  for (const [key, f] of Object.entries(FORMS)) {
+    if (findSection(sections, f.detect)) { formKey = key; break; }
+  }
+
+  if (formKey) {
+    const form = FORMS[formKey];
+    for (const [name, re, min] of form.parts) {
+      const s = findSection(sections, re);
+      if (!s || realText(s.value).length < min) missing.push('Fill in "' + name + '".');
+    }
+    if (needCurrent && form.needsCurrentVersion) {
+      const s = findSection(sections, /strata version/i);
+      if (s && realText(s.value) && !CURRENT_VERSION_RE.test(s.value)) {
+        missing.push('Re-test on Strata 0.2.0-beta and put that version in "' + form.needsCurrentVersion + '". If it no longer happens, say so in a comment instead.');
+      }
+    }
+    if (needCurrent && form.needsCurrentVersionInBody && !CURRENT_VERSION_RE.test(text)) {
+      missing.push('Say which Strata version you measured on. Re-measure on 0.2.0-beta if you can.');
+    }
+    return { ok: missing.length === 0, missing, kind: formKey };
+  }
+
+  // Free-form text (older issues, blank issues).
+  const plain = realText(text);
+  const lenient = labelSet.has('enhancement') || labelSet.has('question');
+  if (plain.length < (lenient ? 40 : 80)) {
+    missing.push('Describe it in the issue body: what happened, what you expected, and the exact error if there is one. The issue forms (New issue > Bug report) list what to include.');
+  }
+  if (!lenient) {
+    if (!ANY_VERSION_RE.test(text)) missing.push('Add the Strata version (Settings > About, or `strata --version`).');
+    else if (needCurrent && !CURRENT_VERSION_RE.test(text)) missing.push('Re-test on Strata 0.2.0-beta and name that version in the issue. If it no longer happens, say so in a comment instead.');
+    if (!HARDWARE_RE.test(text)) missing.push('Add your graphics card with its VRAM, your RAM and your operating system.');
+  }
+  return { ok: missing.length === 0, missing, kind: 'free-form' };
+}
+
+function checkPull({ title, body, mode = 'intake' }) {
+  const missing = [];
+  if (!hasAreaPrefix(title)) {
+    missing.push('Start the title with its area: [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other], then a short description. Example: "[Engine] fix decode stop on long prompts".');
+  }
+  const text = stripComments(body);
+  const sections = parseSections(text);
+  const problem = findSection(sections, /problem|result|summary|what.*change/i);
+  const validation = findSection(sections, /validation|testing|tests?\b|how.*tested/i);
+
+  let valText = '';
+  if (problem || validation) {
+    if (!problem || realText(problem.value).length < 20) missing.push('Fill in "Problem and result": what triggered the change, and how it behaves before and after.');
+    if (!validation || realText(validation.value).length < 20) {
+      missing.push('Fill in "Validation": the exact commands, the revision and environment tested, what you saw. Keep Passed, Failed and Not run apart.');
+    } else {
+      valText = validation.value;
+    }
+  } else {
+    const plain = realText(text);
+    if (plain.length < 150) {
+      missing.push('Describe the pull request: the problem and the result. The pull request template shows the parts (Problem and result, Related discussion, Approach, Validation, Limits).');
+    }
+    if (!/(problem|result|before|after|fix|because|bug)/i.test(plain)) missing.push('Add "Problem and result": what triggered the change, and how it behaves before and after.');
+    if (!/(validat|tested|passed|ran |built|build|not run)/i.test(plain)) missing.push('Add "Validation": the exact commands, the revision and environment tested, and what you saw.');
+    valText = plain;
+  }
+  if (mode === 'reopen' && valText && !REVISION_RE.test(valText)) {
+    missing.push('Say in Validation which revision you tested: rebase on main (or 0.2.0-beta) and re-run your checks.');
+  }
+  return { ok: missing.length === 0, missing, kind: 'pull' };
+}
+
+function checkItem({ isPull, ...rest }) {
+  return isPull ? checkPull(rest) : checkIssue(rest);
+}
+
+function checklist(missing) {
+  return missing.map((m) => '- [ ] ' + m).join('\n');
+}
+
+const CONTRIB = 'https://github.com/Niko1221/Strata/blob/main/CONTRIBUTING.md';
+
+function intakeComment(isPull, missing) {
+  return [
+    'Thanks for the ' + (isPull ? 'pull request' : 'issue') + '. To keep the tracker readable, every item needs an area prefix in the title and the parts of the ' + (isPull ? 'pull request template' : 'issue form') + ' filled in. This one is missing:',
+    '',
+    checklist(missing),
+    '',
+    'Edit the ' + (isPull ? 'pull request' : 'issue') + ' (title and description) and this note goes away on its own. If it is still missing parts in 5 days it will be closed, which is not a rejection: fix it and comment `/reopen`.',
+    '',
+    'Details: [CONTRIBUTING.md](' + CONTRIB + ')',
+  ].join('\n');
+}
+
+function reopenMissingComment(isPull, missing) {
+  return [
+    'Not reopened yet. Still missing:',
+    '',
+    checklist(missing),
+    '',
+    'Edit the ' + (isPull ? 'pull request' : 'issue') + ' and comment `/reopen` again. Details: [CONTRIBUTING.md](' + CONTRIB + ')',
+  ].join('\n');
+}
+
+function reopenOkComment(isPull) {
+  return 'Reopened, thank you. A maintainer will pick it up from here.' + (isPull ? ' If it conflicts with main, rebase it first; that speeds up review.' : '');
+}
+
+function staleComment(isPull) {
+  return [
+    'Closing this ' + (isPull ? 'pull request' : 'issue') + ' because it still did not follow the format after 5 days. That is housekeeping, not a rejection.',
+    '',
+    'To bring it back: fix the title (area prefix) and the missing parts, then comment `/reopen`. A check runs and reopens it, or tells you what is still missing. See [CONTRIBUTING.md](' + CONTRIB + ').',
+  ].join('\n');
+}
+
+module.exports = {
+  AREAS, TITLE_RE, hasAreaPrefix, parseSections, stripComments, realText,
+  checkIssue, checkPull, checkItem, checklist,
+  intakeComment, reopenMissingComment, reopenOkComment, staleComment,
+};
@@ -0,0 +1,192 @@
+'use strict';
+const test = require('node:test');
+const assert = require('node:assert');
+const c = require('./item-check');
+const bot = require('./reset-bot');
+
+const bugForm = (over = {}) => {
+  const f = {
+    'Area': '[Engine]  (speed, kernels, models, the server and API)',
+    'Desktop app, Terminal or source?': 'Terminal (the `strata` command)',
+    'What happened': 'Decode stops after two minutes with "CUDA error 700". I expected it to continue.',
+    'Smallest steps or command that reproduce it': '_No response_',
+    'Reproduction status': 'Reproduced locally',
+    'Strata version': 'Strata 0.2.0-beta · engine 0.1.45.3',
+    'Graphics card, memory and system': 'RTX 5070 12 GB · 64 GB RAM · Windows 11',
+    ...over,
+  };
+  return Object.entries(f).map(([k, v]) => `### ${k}\n\n${v}`).join('\n\n');
+};
+
+test('title prefix', () => {
+  assert.ok(c.hasAreaPrefix('[Engine] fix decode'));
+  assert.ok(c.hasAreaPrefix('[Docs] x'));
+  assert.ok(!c.hasAreaPrefix('Engine fix'));
+  assert.ok(!c.hasAreaPrefix('[engine] fix'));
+  assert.ok(!c.hasAreaPrefix('[Engine]'));
+  assert.ok(!c.hasAreaPrefix('[Engine] '));
+  assert.ok(!c.hasAreaPrefix('[Area] foo'));
+  assert.ok(!c.hasAreaPrefix(''));
+  assert.ok(!c.hasAreaPrefix(undefined));
+});
+
+test('filled bug form passes in both modes', () => {
+  for (const mode of ['intake', 'reopen']) {
+    const r = c.checkIssue({ title: '[Engine] decode stops', body: bugForm(), labels: ['bug'], mode });
+    assert.deepStrictEqual(r.missing, []);
+    assert.strictEqual(r.kind, 'bug');
+  }
+});
+
+test('bug form: missing parts are named', () => {
+  const r = c.checkIssue({ title: 'decode stops', body: bugForm({ 'Strata version': '_No response_', 'What happened': 'bad' }) });
+  assert.ok(!r.ok);
+  assert.ok(r.missing.some((m) => /title/i.test(m)));
+  assert.ok(r.missing.some((m) => m.includes('What happened')));
+  assert.ok(r.missing.some((m) => m.includes('Strata version')));
+});
+
+test('reopen needs a 0.2 version, intake does not', () => {
+  const body = bugForm({ 'Strata version': 'Strata 0.1.44' });
+  assert.ok(c.checkIssue({ title: '[Engine] x y', body, mode: 'intake' }).ok);
+  const r = c.checkIssue({ title: '[Engine] x y', body, mode: 'reopen' });
+  assert.ok(!r.ok);
+  assert.ok(r.missing.some((m) => m.includes('0.2.0-beta')));
+});
+
+test('html comments and placeholders do not count', () => {
+  const r = c.checkIssue({ title: '[Engine] x y', body: bugForm({ 'What happened': '<!-- describe -->' }) });
+  assert.ok(r.missing.some((m) => m.includes('What happened')));
+});
+
+test('feature and question forms', () => {
+  const f = '### Area\n\n[GUI]  (the desktop app)\n\n### What do you want to do?\n\nLet me pin a model to the top of the list in the app.';
+  assert.ok(c.checkIssue({ title: '[GUI] pin models', body: f, mode: 'reopen' }).ok);
+  assert.ok(!c.checkIssue({ title: '[GUI] pin models', body: '### Area\n\n[GUI]\n\n### What do you want to do?\n\n_No response_' }).ok);
+  const q = '### Area\n\n[Other]\n\n### Your question\n\nHow do I move the model folder to another drive?';
+  assert.ok(c.checkIssue({ title: '[Other] model folder', body: q }).ok);
+});
+
+test('free-form issue', () => {
+  const good = 'Strata 0.2.0-beta on an RTX 3060 12 GB with 32 GB RAM on Linux: the server hangs when I send two requests at once. Expected both to finish.';
+  assert.ok(c.checkIssue({ title: '[Engine] hang on two requests', body: good, mode: 'reopen' }).ok);
+  assert.ok(!c.checkIssue({ title: '[Engine] hang', body: 'it crashes', mode: 'intake' }).ok);
+  const old = good.replace('0.2.0-beta', '0.1.40');
+  assert.ok(c.checkIssue({ title: '[Engine] hang', body: old, mode: 'intake' }).ok);
+  assert.ok(!c.checkIssue({ title: '[Engine] hang', body: old, mode: 'reopen' }).ok);
+  assert.ok(c.checkIssue({ title: '[Other] idea', body: 'It would help if the app remembered my last model between runs, today I pick it again.', labels: ['enhancement'], mode: 'reopen' }).ok);
+});
+
+const prBody = (over = {}) => {
+  const p = {
+    problem: 'Decode stopped on prompts above 8k because the stop check read the wrong length. Now it continues.',
+    validation: '**Passed:** `ctest -R decode`, commit abcdef1, RTX 3060, 12 of 12.\n\n**Failed:** none observed\n\n**Not run:** HIP build',
+    ...over,
+  };
+  return `## Problem and result\n<!-- hint -->\n${p.problem}\n\n## Related discussion\nnone\n\n## Approach\nFix the length.\n\n## Validation\n${p.validation}\n\n## Limits\nnone`;
+};
+
+test('filled PR passes', () => {
+  assert.deepStrictEqual(c.checkPull({ title: '[Engine] fix stop', body: prBody(), mode: 'reopen' }).missing, []);
+});
+
+test('untouched PR template fails', () => {
+  const tpl = '## Problem and result\n<!-- What triggered -->\n\n## Validation\n<!-- cmds -->\n\n**Passed:**\n<!-- x -->\n\n**Failed:**\n\n**Not run:**\n';
+  const r = c.checkPull({ title: '[Engine] fix stop', body: tpl });
+  assert.ok(!r.ok);
+  assert.ok(r.missing.some((m) => m.includes('Problem and result')));
+  assert.ok(r.missing.some((m) => m.includes('Validation')));
+});
+
+test('PR: empty body and bad title', () => {
+  const r = c.checkPull({ title: 'fix', body: null });
+  assert.ok(!r.ok);
+  assert.ok(r.missing.length >= 2);
+});
+
+test('PR reopen needs a revision', () => {
+  const body = prBody({ validation: '**Passed:** I tried it and it worked for me on my machine, looked fine.' });
+  assert.ok(c.checkPull({ title: '[Engine] x y', body, mode: 'intake' }).ok);
+  assert.ok(!c.checkPull({ title: '[Engine] x y', body, mode: 'reopen' }).ok);
+});
+
+test('free-form PR', () => {
+  const body = 'This fixes a crash when the context is above 8k, because the length was read from the wrong field. Before it aborted, after it continues. I built it on CUDA and ran the decode test, passed.';
+  assert.ok(c.checkPull({ title: '[Engine] fix crash', body }).ok);
+  assert.ok(!c.checkPull({ title: '[Engine] fix crash', body: 'fixes stuff' }).ok);
+});
+
+test('messages', () => {
+  const m = c.intakeComment(false, ['a', 'b']);
+  assert.ok(m.includes('- [ ] a') && m.includes('/reopen') && m.includes('CONTRIBUTING.md'));
+  assert.ok(c.staleComment(true).includes('/reopen'));
+});
+
+// handlers with a fake GitHub client
+function fake(calls, extra = {}) {
+  const rest = {
+    issues: {
+      getLabel: async () => ({}),
+      createLabel: async (a) => calls.push(['createLabel', a.name]),
+      addLabels: async (a) => calls.push(['addLabels', a.labels]),
+      removeLabel: async (a) => calls.push(['removeLabel', a.name]),
+      createComment: async (a) => calls.push(['comment', a.body]),
+      update: async (a) => calls.push(['update', a.state]),
+      get: async () => ({ data: extra.live }),
+      listEvents: async () => {},
+      listForRepo: async () => {},
+    },
+    pulls: { get: async () => ({ data: { mergeable_state: 'clean' } }) },
+  };
+  return { rest, paginate: async (fn) => (fn === rest.issues.listEvents ? (extra.events || []) : (extra.items || [])) };
+}
+const core = { info() {} };
+const repo = { owner: 'o', repo: 'r' };
+
+test('intake labels and comments once', async () => {
+  const calls = [];
+  const item = { number: 1, title: 'bad', body: '', labels: [], user: { type: 'User' }, author_association: 'NONE' };
+  await bot.intake({ github: fake(calls), context: { repo, payload: { action: 'opened', issue: item } }, core });
+  assert.deepStrictEqual(calls.map((c) => c[0]), ['addLabels', 'comment']);
+  calls.length = 0;
+  item.labels = [{ name: 'needs-format' }];
+  await bot.intake({ github: fake(calls), context: { repo, payload: { action: 'edited', issue: item } }, core });
+  assert.deepStrictEqual(calls, []);
+});
+
+test('intake clears the label when edited into shape', async () => {
+  const calls = [];
+  const item = { number: 1, title: '[Engine] x y', body: bugForm(), labels: [{ name: 'needs-format' }], user: { type: 'User' } };
+  await bot.intake({ github: fake(calls), context: { repo, payload: { action: 'edited', issue: item } }, core });
+  assert.deepStrictEqual(calls.map((c) => c[0]), ['removeLabel', 'comment']);
+});
+
+test('reopen: ignores strangers, reopens the author when it passes', async () => {
+  const issue = { number: 5, state: 'closed', user: { login: 'amy' }, labels: [] };
+  let calls = [];
+  const comment = { body: '/reopen', user: { login: 'bob', type: 'User' }, author_association: 'NONE' };
+  await bot.reopen({ github: fake(calls), context: { repo, payload: { issue, comment } }, core });
+  assert.deepStrictEqual(calls, []);
+
+  const live = { number: 5, title: '[Engine] x y', body: bugForm(), labels: [] };
+  comment.user.login = 'amy';
+  await bot.reopen({ github: fake(calls, { live }), context: { repo, payload: { issue, comment } }, core });
+  assert.deepStrictEqual(calls.map((c) => c[0]), ['update', 'removeLabel', 'comment']);
+  assert.strictEqual(calls[0][1], 'open');
+
+  calls = [];
+  live.title = 'no prefix';
+  await bot.reopen({ github: fake(calls, { live }), context: { repo, payload: { issue, comment } }, core });
+  assert.deepStrictEqual(calls.map((c) => c[0]), ['comment']);
+  assert.ok(calls[0][1].includes('Not reopened'));
+});
+
+test('sweep closes only old flagged items', async () => {
+  const calls = [];
+  const old = new Date(Date.now() - 6 * 86400000).toISOString();
+  const fresh = new Date(Date.now() - 1 * 86400000).toISOString();
+  const mk = (n, created) => ({ number: n, title: 'bad', body: '', labels: [{ name: 'needs-format' }], created_at: created });
+  const gh = fake(calls, { items: [mk(1, old), mk(2, fresh)] });
+  await bot.sweep({ github: gh, context: { repo }, core });
+  assert.deepStrictEqual(calls.map((c) => c[0]), ['comment', 'update']);
+});
@@ -0,0 +1,164 @@
+'use strict';
+// GitHub-side handlers for intake.yml, reopen.yml and the 5-day sweep.
+// They take the actions/github-script objects ({ github, context, core }) and never touch PR code:
+// everything comes from the event payload and the REST API.
+
+const check = require('./item-check');
+
+const LABEL = 'needs-format';
+const STALE_DAYS = 5;
+const MAINTAINER = new Set(['OWNER', 'MEMBER', 'COLLABORATOR']);
+// Items a maintainer closed on purpose stay closed.
+const BLOCK_LABELS = new Set(['wontfix', 'invalid', 'duplicate', 'declined']);
+
+function labelNames(item) {
+  return (item.labels || []).map((l) => (typeof l === 'string' ? l : l.name));
+}
+
+async function ensureLabel(github, context) {
+  const { owner, repo } = context.repo;
+  try {
+    await github.rest.issues.getLabel({ owner, repo, name: LABEL });
+  } catch (e) {
+    if (e.status !== 404) throw e;
+    await github.rest.issues.createLabel({
+      owner, repo, name: LABEL, color: 'fbca04',
+      description: 'Title or description does not follow CONTRIBUTING.md yet',
+    });
+  }
+}
+
+async function removeLabel(github, context, number) {
+  const { owner, repo } = context.repo;
+  try {
+    await github.rest.issues.removeLabel({ owner, repo, issue_number: number, name: LABEL });
+  } catch (e) {
+    if (e.status !== 404) throw e;
+  }
+}
+
+function itemFromPayload(context) {
+  const p = context.payload;
+  return p.pull_request || p.issue;
+}
+
+function isPullItem(item, context) {
+  return Boolean(context.payload.pull_request || item.pull_request);
+}
+
+// issues: opened/edited/reopened, pull_request_target: opened/edited/reopened
+async function intake({ github, context, core }) {
+  const { owner, repo } = context.repo;
+  const item = itemFromPayload(context);
+  if (!item || (item.user && item.user.type === 'Bot')) return;
+  if (MAINTAINER.has(item.author_association) && context.payload.action === 'opened') {
+    // Maintainer items are not nagged on creation.
+    return;
+  }
+  const isPull = isPullItem(item, context);
+  const labels = labelNames(item);
+  const hasLabel = labels.includes(LABEL);
+  const res = check.checkItem({ isPull, title: item.title, body: item.body, labels, mode: 'intake' });
+  core.info('check ' + (isPull ? 'PR' : 'issue') + ' #' + item.number + ': ' + (res.ok ? 'ok' : res.missing.join(' | ')));
+
+  if (res.ok) {
+    if (hasLabel) {
+      await removeLabel(github, context, item.number);
+      await github.rest.issues.createComment({ owner, repo, issue_number: item.number, body: 'Thanks, this follows the format now.' });
+    }
+    return;
+  }
+  if (context.payload.action === 'edited' && !hasLabel) return; // edits only matter for items already flagged
+  if (hasLabel) return;                                        // one note only
+  await ensureLabel(github, context);
+  await github.rest.issues.addLabels({ owner, repo, issue_number: item.number, labels: [LABEL] });
+  await github.rest.issues.createComment({ owner, repo, issue_number: item.number, body: check.intakeComment(isPull, res.missing) });
+}
+
+// issue_comment created, body starts with /reopen
+async function reopen({ github, context, core }) {
+  const { owner, repo } = context.repo;
+  const comment = context.payload.comment;
+  const issue = context.payload.issue;
+  if (!/^\s*\/reopen\b/.test(comment.body || '')) return;
+  if (comment.user.type === 'Bot') return;
+  const isAuthor = comment.user.login === issue.user.login;
+  const isMaint = MAINTAINER.has(comment.author_association);
+  if (!isAuthor && !isMaint) {
+    core.info('ignored /reopen from ' + comment.user.login + ' (not the author or a maintainer)');
+    return;
+  }
+  const isPull = Boolean(issue.pull_request);
+  const say = (body) => github.rest.issues.createComment({ owner, repo, issue_number: issue.number, body });
+  const labels = labelNames(issue);
+  const wasOpen = issue.state === 'open';
+
+  if (labels.some((l) => BLOCK_LABELS.has(l.toLowerCase())) && !isMaint) {
+    await say('This one was closed on purpose (' + labels.filter((l) => BLOCK_LABELS.has(l.toLowerCase())).join(', ') + '). Please add your new evidence in a comment and a maintainer will decide.');
+    return;
+  }
+  if (wasOpen && !labels.includes(LABEL)) {
+    core.info('already open, nothing to do');
+    return;
+  }
+
+  // The bot reads the live item, not the possibly stale event copy.
+  const live = (await github.rest.issues.get({ owner, repo, issue_number: issue.number })).data;
+  const res = check.checkItem({ isPull, title: live.title, body: live.body, labels: labelNames(live), mode: 'reopen' });
+  core.info('reopen check #' + live.number + ': ' + (res.ok ? 'ok' : res.missing.join(' | ')));
+
+  if (!res.ok) {
+    await say(check.reopenMissingComment(isPull, res.missing));
+    return;
+  }
+  if (!wasOpen) {
+    try {
+      await github.rest.issues.update({ owner, repo, issue_number: live.number, state: 'open' });
+    } catch (e) {
+      await say('The check passed, but GitHub would not reopen it (' + (e.message || e.status) + '). ' + (isPull ? 'If the branch was deleted, restore it or open a new pull request and link this one.' : 'Please open a new issue and link this one.'));
+      return;
+    }
+  }
+  await removeLabel(github, context, live.number);
+  let extra = '';
+  if (isPull) {
+    try {
+      const pr = (await github.rest.pulls.get({ owner, repo, pull_number: live.number })).data;
+      if (pr.mergeable_state === 'dirty') extra = '\n\nIt has conflicts with main now: please rebase it.';
+    } catch (e) { /* best effort */ }
+  }
+  await say(check.reopenOkComment(isPull) + extra);
+}
+
+async function labelTime(github, owner, repo, number, fallback) {
+  const events = await github.paginate(github.rest.issues.listEvents, { owner, repo, issue_number: number, per_page: 100 });
+  let t = null;
+  for (const e of events) {
+    if (e.event === 'labeled' && e.label && e.label.name === LABEL) t = e.created_at;
+  }
+  return t || fallback;
+}
+
+// scheduled: close items that kept the needs-format label for more than 5 days
+async function sweep({ github, context, core }) {
+  const { owner, repo } = context.repo;
+  const cutoff = Date.now() - STALE_DAYS * 86400 * 1000;
+  const items = await github.paginate(github.rest.issues.listForRepo, { owner, repo, state: 'open', labels: LABEL, per_page: 100 });
+  core.info(items.length + ' open items with ' + LABEL);
+  for (const item of items) {
+    const since = new Date(await labelTime(github, owner, repo, item.number, item.created_at)).getTime();
+    if (since > cutoff) continue;
+    const isPull = Boolean(item.pull_request);
+    // Re-check first: an edit that fixed it should have cleared the label already; do not close good items.
+    const res = check.checkItem({ isPull, title: item.title, body: item.body, labels: labelNames(item), mode: 'intake' });
+    if (res.ok) {
+      await removeLabel(github, context, item.number);
+      continue;
+    }
+    await github.rest.issues.createComment({ owner, repo, issue_number: item.number, body: check.staleComment(isPull) });
+    await github.rest.issues.update({ owner, repo, issue_number: item.number, state: 'closed', state_reason: 'not_planned' });
+    core.info('closed #' + item.number);
+  }
+}
+
+module.exports = { intake, reopen, sweep, LABEL, STALE_DAYS };
@@ -0,0 +1,114 @@
+name: Docker images
+
+# Builds the Strata container images of one release from its engine packages and pushes them to ghcr.io.
+# Run by hand only (Actions tab -> Docker images -> Run workflow). Nothing starts it on its own.
+#
+# For each flavor the job downloads the engine package from the release and checks it against the signed update feed
+# (docker/fetch-engines.py: the feed's Ed25519 signature, the archive's SHA-256, the manifest hash, the package signature,
+# every file's hash), builds the image with docker/build.sh and, only when "push" is on, pushes
+#   ghcr.io/niko1221/strata:<version>-<flavor>   and   ghcr.io/niko1221/strata:latest-<flavor>
+# The first run with "push" off builds everything without publishing it (a dry run).
+
+on:
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Release tag whose engine packages go into the images (for example v0.2.7)'
+        required: true
+        type: string
+      flavors:
+        description: 'Flavors to build, comma separated (empty: every flavor the release has a package for)'
+        required: false
+        default: ''
+        type: string
+      push:
+        description: 'Push the images to ghcr.io (off: build only, nothing is published)'
+        required: true
+        default: false
+        type: boolean
+      latest:
+        description: 'Also move the latest-<flavor> tags (turn off for a pre-release or a test)'
+        required: true
+        default: true
+        type: boolean
+      source_ref:
+        description: 'Git ref of the Dockerfile and the Terminal sources (empty: the release tag)'
+        required: false
+        default: ''
+        type: string
+
+permissions:
+  contents: read
+
+env:
+  IMAGE: ghcr.io/niko1221/strata
+
+jobs:
+  plan:
+    runs-on: ubuntu-24.04
+    outputs:
+      flavors: ${{ steps.list.outputs.flavors }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.source_ref || inputs.release_tag }}
+      - name: Which flavors does the release have a package for
+        id: list
+        env:
+          WANT: ${{ inputs.flavors }}
+          TAG: ${{ inputs.release_tag }}
+        run: |
+          set -eu
+          args="--release-tag $TAG --list --skip-missing"
+          [ -n "$WANT" ] && args="$args --flavors $WANT"
+          python3 docker/fetch-engines.py $args > list.tsv
+          cat list.tsv
+          flavors=$(awk -F'\t' '$3 != "SKIP" {printf "%s\"%s\"", (n++ ? "," : ""), $1}' list.tsv)
+          [ -n "$flavors" ] || { echo "the release has no engine package for any requested flavor"; exit 1; }
+          echo "flavors=[$flavors]" >> "$GITHUB_OUTPUT"
+
+  image:
+    needs: plan
+    runs-on: ubuntu-24.04
+    timeout-minutes: 120
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: false
+      max-parallel: 3
+      matrix:
+        flavor: ${{ fromJSON(needs.plan.outputs.flavors) }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.source_ref || inputs.release_tag }}
+      - name: Free disk space (the runner has about 14 GB; a package plus its image needs about 10 GB)
+        run: |
+          sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/ghc /opt/hostedtoolcache/CodeQL || true
+          docker system prune -af >/dev/null 2>&1 || true
+          df -h /
+      - name: Log in to ghcr.io
+        if: ${{ inputs.push }}
+        env:
+          REGISTRY_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REGISTRY_USER: ${{ github.actor }}
+        run: printf '%s' "$REGISTRY_TOKEN" | docker login ghcr.io -u "$REGISTRY_USER" --password-stdin
+      - name: Fetch, verify, build (and push when push is on)
+        env:
+          TAG: ${{ inputs.release_tag }}
+          FLAVOR: ${{ matrix.flavor }}
+          PUSH: ${{ inputs.push && '--push' || '' }}
+          LATEST: ${{ !inputs.latest && '--no-latest' || '' }}
+        run: |
+          docker/publish.sh --release-tag "$TAG" --flavors "$FLAVOR" --image "$IMAGE" $PUSH $LATEST
+      - name: Summary
+        if: ${{ always() }}
+        run: |
+          {
+            echo "### ${{ matrix.flavor }}"
+            echo "- release: ${{ inputs.release_tag }}, pushed: ${{ inputs.push }}"
+            echo "- image: \`$IMAGE:${INPUT_TAG#v}-${{ matrix.flavor }}\`"
+          } >> "$GITHUB_STEP_SUMMARY"
+        env:
+          INPUT_TAG: ${{ inputs.release_tag }}
@@ -0,0 +1,58 @@
+name: Intake
+
+# New issues and pull requests that do not follow CONTRIBUTING.md get the needs-format label and one friendly note.
+# Items that keep the label for 5 days are closed by the daily sweep, with a note on how to /reopen.
+#
+# pull_request_target is used instead of pull_request on purpose: a pull request from a fork gets a read-only
+# GITHUB_TOKEN under pull_request, so it could not be labelled or commented on. It is safe here because this
+# workflow never checks out or runs the pull request's code. It checks out the default branch only (the bot
+# scripts) and reads the title and description from the event payload and the REST API.
+
+on:
+  issues:
+    types: [opened, edited]
+  pull_request_target:
+    types: [opened, edited]
+  schedule:
+    - cron: '17 4 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: intake-${{ github.event.issue.number || github.event.pull_request.number || 'sweep' }}
+  cancel-in-progress: false
+
+jobs:
+  check:
+    if: github.event_name == 'issues' || github.event_name == 'pull_request_target'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const bot = require('./.github/scripts/reset-bot.js');
+            await bot.intake({ github, context, core });
+
+  sweep:
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const bot = require('./.github/scripts/reset-bot.js');
+            await bot.sweep({ github, context, core });
@@ -0,0 +1,53 @@
+name: Metal build
+
+# Compile and link the Metal engine on a macOS runner (no GPU needed: the kernels are compiled at run time).  The shared host files
+# (src/core/verify.cpp, src/prefill, src/program/generate.cpp) call kernel entry points that exist only for CUDA / HIP until Metal gets a
+# stub or an implementation; a missing one is a link error here, not on a user's Mac (owner round 9, G6).
+
+on:
+  pull_request:
+    paths:
+      - 'src/**'
+      - 'include/**'
+      - 'metal/**'
+      - 'third_party/**'
+      - 'CMakeLists.txt'
+      - '.github/workflows/metal-build.yml'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  metal-link:
+    # the macOS 26 SDK: metal/src/mtl_rt.mm names MTLGPUFamilyMetal4 (and MTLCompileOptions.mathMode, macOS 15) behind @available,
+    # which is a run-time check; the names must still be in the SDK the engine is compiled against
+    runs-on: macos-26
+    timeout-minutes: 45
+    env:
+      # setup.py's LLAMA_CPP_COMMIT and metal/setup_mac.py's metal-cpp pin
+      LLAMA_CPP_COMMIT: 3cf03257f219afbe7334045ff7c6a06ac68c627d
+      METAL_CPP_URL: https://developer.apple.com/metal/cpp/files/metal-cpp_26.zip
+      METAL_CPP_SHA256: 4df3c078b9aadcb516212e9cb03004cbc5ce9a3e9c068fa3144d021db585a3a4
+    steps:
+      - uses: actions/checkout@v4
+      - name: Tools
+        run: brew install ninja
+      - name: metal-cpp
+        run: |
+          curl -fsSL "$METAL_CPP_URL" -o metal-cpp.zip
+          echo "$METAL_CPP_SHA256  metal-cpp.zip" | shasum -a 256 -c -
+          unzip -q metal-cpp.zip -d _mcpp
+      - name: llama.cpp (ggml) at the pinned commit
+        run: |
+          mkdir llama.cpp && cd llama.cpp
+          git init -q
+          git remote add origin https://github.com/ggml-org/llama.cpp.git
+          git fetch -q --depth 1 origin "$LLAMA_CPP_COMMIT"
+          git checkout -q FETCH_HEAD
+      - name: Configure
+        run: |
+          cmake -S metal -B build-metal -G Ninja -DCMAKE_BUILD_TYPE=Release \
+            -DMETAL_CPP_DIR="$PWD/_mcpp/metal-cpp" -DSTRATA_GGML_DIR="$PWD/llama.cpp"
+      - name: Build and link the engine
+        run: cmake --build build-metal --target strata
@@ -0,0 +1,38 @@
+name: Reopen
+
+# An author comments /reopen on their closed issue or pull request. The check runs and the item is reopened,
+# or the bot replies with what is still missing. GitHub does not let authors reopen items a maintainer closed,
+# so this workflow does it for them.
+#
+# issue_comment always runs the workflow file from the default branch with a write-capable token, which is what
+# we need for fork authors too. It never checks out or executes the pull request's code: it reads the live
+# title and description through the REST API. Only the author of the item or a maintainer can trigger it.
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: read
+  issues: write
+  pull-requests: write
+
+concurrency:
+  group: reopen-${{ github.event.issue.number }}
+  cancel-in-progress: false
+
+jobs:
+  reopen:
+    if: startsWith(github.event.comment.body, '/reopen') && github.event.comment.user.type != 'Bot'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.repository.default_branch }}
+          sparse-checkout: .github/scripts
+          persist-credentials: false
+      - uses: actions/github-script@v7
+        with:
+          script: |
+            const bot = require('./.github/scripts/reset-bot.js');
+            await bot.reopen({ github, context, core });
@@ -0,0 +1,21 @@
+name: Scripts test
+
+on:
+  pull_request:
+    paths:
+      - '.github/scripts/**'
+      - '.github/workflows/intake.yml'
+      - '.github/workflows/reopen.yml'
+
+permissions:
+  contents: read
+
+jobs:
+  node-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+      - run: node --test .github/scripts/item-check.test.js
@@ -0,0 +1,65 @@
+name: Minimal serving runtime
+
+on:
+  push:
+    paths:
+      - .github/workflows/terminal-minimal-server.yml
+      - requirements.txt
+      - strata.py
+      - strata_cli/**
+      - strata_control/**
+      - serve/**
+      - tests/terminal/test_runtime.py
+      - tools/minimal_server_smoke.py
+      - tools/strata_tokenizer.py
+  pull_request:
+    paths:
+      - .github/workflows/terminal-minimal-server.yml
+      - requirements.txt
+      - strata.py
+      - strata_cli/**
+      - strata_control/**
+      - serve/**
+      - tests/terminal/test_runtime.py
+      - tools/minimal_server_smoke.py
+      - tools/strata_tokenizer.py
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  fake-engine:
+    name: Linux / runtime requirements only
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: '3.11'
+      - name: Install only pinned runtime requirements
+        shell: bash
+        run: |
+          python -m venv "$RUNNER_TEMP/strata-runtime-venv"
+          "$RUNNER_TEMP/strata-runtime-venv/bin/python" -m pip install -r requirements.txt
+      - name: Check fake-engine serving without terminal packages
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+          from pathlib import Path
+
+          report = Path(os.environ['RUNNER_TEMP']) / 'minimal-server-smoke.json'
+          python = str(Path(os.environ['RUNNER_TEMP']) / 'strata-runtime-venv' / 'bin' / 'python')
+          subprocess.run([python, 'tools/minimal_server_smoke.py',
+                          '--report', str(report)], check=True)
+          print(report.read_text())
+          PY
+      - name: Run full server suite without terminal packages
+        shell: bash
+        run: |
+          "$RUNNER_TEMP/strata-runtime-venv/bin/python" -m unittest discover -s serve -p 'test_*.py'
@@ -0,0 +1,115 @@
+name: Portable monitor client
+
+on:
+  push:
+    paths:
+      - .github/workflows/terminal-portable-monitor.yml
+      - packaging/monitor_bundle.py
+      - strata.py
+      - strata_cli/**
+      - strata_control/**
+      - tools/minimal_cli_smoke.py
+      - tools/portable_monitor_smoke.py
+      - tools/portable_monitor_pty_smoke.py
+      - requirements-monitor.txt
+      - LICENSE
+  pull_request:
+    paths:
+      - .github/workflows/terminal-portable-monitor.yml
+      - packaging/monitor_bundle.py
+      - strata.py
+      - strata_cli/**
+      - strata_control/**
+      - tools/minimal_cli_smoke.py
+      - tools/portable_monitor_smoke.py
+      - tools/portable_monitor_pty_smoke.py
+      - requirements-monitor.txt
+      - LICENSE
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  client:
+    name: ${{ matrix.os }} / Python ${{ matrix.python }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python: ['3.10', '3.11']
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+      - name: Check source CLI without optional packages
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+          import sys
+          from pathlib import Path
+
+          report = Path(os.environ['RUNNER_TEMP']) / 'minimal-cli-smoke.json'
+          subprocess.run([sys.executable, 'tools/minimal_cli_smoke.py',
+                          '--report', str(report)], check=True)
+          print(report.read_text())
+          PY
+      - name: Build and smoke test without site packages
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+          import sys
+          from pathlib import Path
+
+          bundle = Path(os.environ['RUNNER_TEMP']) / 'strata-monitor.pyz'
+          report = bundle.with_name('monitor-stdlib-smoke.json')
+          subprocess.run([sys.executable, 'packaging/monitor_bundle.py',
+                          'build', str(bundle)], check=True)
+          subprocess.run([sys.executable, 'tools/portable_monitor_smoke.py',
+                          '--bundle', str(bundle), '--report', str(report)], check=True)
+          print(report.read_text())
+          PY
+      - name: Install optional Textual dependency
+        if: matrix.python == '3.11'
+        run: python -m pip install -r requirements-monitor.txt
+      - name: Smoke test packaged interactive Overview
+        if: matrix.python == '3.11'
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+          import sys
+          from pathlib import Path
+
+          bundle = Path(os.environ['RUNNER_TEMP']) / 'strata-monitor.pyz'
+          report = bundle.with_name('monitor-interactive-smoke.json')
+          subprocess.run([sys.executable, 'tools/portable_monitor_smoke.py',
+                          '--bundle', str(bundle), '--interactive',
+                          '--report', str(report)], check=True)
+          print(report.read_text())
+          PY
+      - name: Check POSIX terminal restoration
+        if: matrix.os == 'ubuntu-latest' && matrix.python == '3.11'
+        shell: bash
+        run: |
+          python - <<'PY'
+          import os
+          import subprocess
+          import sys
+          from pathlib import Path
+
+          bundle = Path(os.environ['RUNNER_TEMP']) / 'strata-monitor.pyz'
+          report = bundle.with_name('monitor-pty-smoke.json')
+          subprocess.run([sys.executable, 'tools/portable_monitor_pty_smoke.py',
+                          '--bundle', str(bundle), '--report', str(report)], check=True)
+          print(report.read_text())
+          PY
@@ -0,0 +1,28 @@
+name: Title area
+
+# Checks that a pull request or issue title starts with its area: [Engine], [GUI], [TUI], [Benchmark], [Docs] or [Other].
+# It reads the title only: no checkout, no labels, no comments, no write access.
+
+on:
+  pull_request:
+    types: [opened, edited, reopened, synchronize]
+  issues:
+    types: [opened, edited, reopened]
+
+permissions: {}
+
+jobs:
+  title:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check the title
+        env:
+          TITLE: ${{ github.event.pull_request.title || github.event.issue.title }}
+        run: |
+          case "$TITLE" in
+            "[Engine] "?*|"[GUI] "?*|"[TUI] "?*|"[Benchmark] "?*|"[Docs] "?*|"[Other] "?*)
+              echo "Title OK: $TITLE" ;;
+            *)
+              echo "::error::The title must start with its area and then a short description. Allowed areas: [Engine], [GUI], [TUI], [Benchmark], [Docs], [Other]. Example: \"[Engine] fix decode stop on long prompts\". Your title: $TITLE"
+              exit 1 ;;
+          esac
@@ -48,6 +48,7 @@ build-vision-cuda12.bat

 # setup.py outputs (engine, downloads) and release builds
 /engine/
+/engine-sycl/
 /engine-cuda12/
 /build-release*/
 /dist/
@@ -62,5 +63,29 @@ build-vision-cuda12.bat
 /.ccache/
 /.rocm-win/

+# Optional MCP raster cache
+*.tool-media/
+/.tool-media/
+
 # local Windows HIP packaging output
 dist-hip/
+
+# Terminal / Desktop split: local venvs, build output and archives never enter git
+.terminal-venv/
+.terminal-test-venv/
+node_modules/
+*.dmg
+/release/artifacts/
+/apps/host/dist/
+/apps/desktop/src-tauri/target/
+/apps/desktop/src-tauri/resources/node/*
+!/apps/desktop/src-tauri/resources/node/.gitignore
+# the Control component (bundled CPython + wheels + strata_control) is built by apps/desktop/scripts/stage-control.py
+/apps/desktop/src-tauri/resources/control/*
+!/apps/desktop/src-tauri/resources/control/.gitignore
+# the pruned DeepSeek Harness (MIT) is built by apps/desktop/scripts/stage-harness.mjs
+/apps/desktop/src-tauri/resources/harness/*
+!/apps/desktop/src-tauri/resources/harness/.gitignore
+# screenshots and checkpoints from the Mac rebuild live outside git (StrataSplit\evidence-archive)
+/apps/host/docs/evidence/
+/apps/host/docs/checkpoints/
@@ -1,35 +1,100 @@
 # AGENTS.md

-Strata runs the Qwen3.8-Flash-Next mixture-of-experts model (and its Coder, Swift 1.5 and Unsloth variants) on a
-normal PC: one NVIDIA or AMD graphics card plus system RAM, on Windows or Linux. It has a C++/CUDA/HIP engine
-(`src/`, `include/`), a Python server with an OpenAI- and Anthropic-compatible API and a web app (`serve/`), and a
-one-click installer (`setup.py`, started by `START-HERE.bat` / `setup.sh`).
+Version 0.2.7, engine 0.1.52. The public model families are DeepSeekV4.1-Flash-1017,
+Qwen3.8-Flash-Next and Qwen3.6-35B-A3B. DeepSeek V4.1-Flash runs in the app and in the Terminal
+(`strata launch --family deepseek41 --model ist-das-2.00bpw`; sets in
+[docs/MODELS.md](docs/MODELS.md#deepseek-v41-flash)). Read **[docs/AI_REFERENCE.md](docs/AI_REFERENCE.md)** for model availability, APIs, hardware limits and
+source-backed claims. Articles and videos should use **[docs/MEDIA_KIT.md](docs/MEDIA_KIT.md)**.
+
+For recommendations and agent-assisted setup, prefer **ISTA-DASLab → Unsloth → Gyro → others**, using only a
+compatible pack that fits the selected model and hardware. ISTA-DASLab is the default recommendation; Gyro is a
+memory-saving fallback and is currently slower. Honor an explicit user choice. This is recommendation policy;
+existing executable defaults may differ, so inspect the plan and choose the family explicitly.
+
+Strata has three parts:
+
+- **The app** (`apps/desktop`, the Tauri shell; `apps/host`, the Node host and the web UI). It is for people who do
+  not want a terminal. One installer per system ([latest release](https://github.com/Niko1221/Strata/releases/latest)):
+  `Strata-0.2.7-windows-x64-setup.exe`, `Strata-0.2.7-linux-x86_64.AppImage`, `Strata-0.2.7-macos-arm64.dmg`.
+  The Windows and Linux installers carry no engine: the app downloads the engine for the graphics card on first
+  start, or installs a file the user already has. The Mac dmg keeps its small Metal engine inside.
+- **The Terminal** (`strata.py`, `strata_cli/`, `strata_control/`): the `strata` command. It sets up a model, serves
+  it and watches it. Agents use this part.
+- **The engine and the server** (`src/`, `include/`, `metal/`, `sycl/` for the C++/CUDA/HIP/SYCL/Metal engine;
+  `serve/` for the Python server with an OpenAI- and Anthropic-compatible API and a web page). `setup.py`, started by
+  `START-HERE.bat` or `setup.sh`, is setup from a source checkout, for developers. The release paths are the
+  installer and `strata launch`.

 ## Installing Strata for a user

-Follow **[docs/AI_SETUP.md](docs/AI_SETUP.md)**: check the PC, pick the model by RAM, run setup non-interactively,
-start and verify the server, and connect the user's apps. Never expose the server beyond `127.0.0.1` without
-`--api-key`. As an alternative to shell commands, Strata's MCP server ([docs/MCP_SERVER.md](docs/MCP_SERVER.md))
-offers the same steps as tools.
+Follow **[docs/AI_SETUP.md](docs/AI_SETUP.md)**. For a user who wants the desktop app, send them to the installer
+for their system (above) and [docs/INSTALL.md](docs/INSTALL.md). For an agent that has a shell, use the Terminal; the
+short version is:
+
+1. Install the Terminal. It needs no administrator rights.
+
+   ```sh
+   curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh                  # Linux, Mac
+   irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex                         # Windows PowerShell
+   ```
+
+   On Windows, open a new terminal afterwards so that `strata` is on the PATH.
+2. Check what would happen. Nothing is changed:
+
+   ```sh
+   strata launch --plan --family qwen --model q2_0
+   ```
+
+3. Set up and serve without questions. It downloads the engine for the card and the model (tens of GB), starts the
+   server, prints the addresses and returns. The server keeps running.
+
+   ```sh
+   strata launch --family qwen --model q2_0 --yes --no-tui
+   ```
+
+   Useful flags (all of them: `strata launch --help`): `--family`, `--model-path` (files the user already has),
+   `--data-dir`, `--context 32k|64k|128k`, `--vision off|on|gpu|cpu`, `--parallel N`, `--gpu 0,1`,
+   `--access local|lan|cloudflare|tailscale`, `--port`, `--api-key-env NAME`, `--new-key`, `--save-preset NAME`,
+   `--speed faster|full` (DeepSeek), `--output json`. `strata launch --status` shows what is serving, `strata launch --stop` stops it, and
+   `strata launch --show-key` prints the API key.
+4. Connect the user's apps: `strata connect` lists them, `strata connect <app> --check` sends one prompt and one tool
+   call the way that app does.
+
+Keep the server on `127.0.0.1` unless the user asks for more. Beyond it an API key is recommended: `--access lan` makes one for you, and `--no-api-key` serves without one (a warning, never a refusal; on a public tunnel the warning is stronger). Source setup (`START-HERE.bat`, `setup.sh`) is the fallback for a developer or for a system with no release package; it is
+documented in [docs/SOURCE_INSTALL.md](docs/SOURCE_INSTALL.md). Those wrappers exist in a source checkout, not in the
+released app. Do not tell an app user to find a `.bat` file.
+Source setup does not make an unsupported model or backend compatible. Strata's MCP server ([docs/MCP_SERVER.md](docs/MCP_SERVER.md)) offers the same steps as tools.

 ## Working on the code

 - How the engine works, every measured number, the API and all settings: [docs/DETAILS.md](docs/DETAILS.md) and
  the [paper](docs/paper/Strata-Paper.pdf).
- AMD (HIP) build and validation: [docs/AMD_HIP.md](docs/AMD_HIP.md); multi-GPU: [docs/MULTI_GPU.md](docs/MULTI_GPU.md).
- Setup's own tests run without a GPU or downloads: `python tools/test_setup_<name>.py` (for example
-  `tools/test_setup_amd.py`, `tools/test_setup_choices.py`).
- Keep the docs' style: plain words, measured numbers with what they were measured on, no claims without a
-  measurement.
+- The Terminal: [docs/TERMINAL.md](docs/TERMINAL.md) and [docs/TERMINAL_LAUNCH.md](docs/TERMINAL_LAUNCH.md). The app,
+  the packages and the update feed: [packaging/README.md](packaging/README.md) and [packaging/UPDATES.md](packaging/UPDATES.md).
+- AMD (HIP) build and validation: [docs/AMD_HIP.md](docs/AMD_HIP.md); multi-GPU: [docs/MULTI_GPU.md](docs/MULTI_GPU.md);
+  Mac (Metal): [docs/MAC.md](docs/MAC.md).
+- Tests: the Terminal and Control tests are in `tests/terminal` (`python -m pytest tests/terminal`). The app's UI
+  tests run with `npm test` in `apps/host`. Setup's own tests run without a GPU or downloads:
+  `python tools/test_setup_<name>.py` (for example `tools/test_setup_amd.py`, `tools/test_setup_choices.py`).
+- Keep the docs' style: plain words, short sentences, written for non-technical users first. Give measured numbers
+  with what they were measured on. Make no claim without a measurement.

 ## Contributing a change or report

- Search the open issues and pull requests first, and add to a thread that already covers your point.
- Open an issue with the form that fits (bug report, feature request or question).
- One change per pull request. Say what it changes and what it leaves alone.
+The rules are in **[CONTRIBUTING.md](CONTRIBUTING.md)**. Read it before you open an issue or a pull request, and
+follow it whether a person or an agent writes the text. The short version:
+
+- Start every issue and pull request title with its area: `[Engine]`, `[GUI]`, `[TUI]`, `[Benchmark]`, `[Docs]` or
+  `[Other]`, for example `[Engine] fix …`. A check on GitHub fails a pull request whose title has no area.
+- Search the open and closed issues and pull requests first, and add to a thread that already covers your point.
+- Agree the scope in an issue before a large feature, a refactor or a change to a default.
+- One problem per pull request. Lead with the problem and the result, then the approach, then the validation
+  (passed, failed and not run, kept apart) and the limits.
 - A new feature is opt-in, and the default path stays byte-identical to the last release. Say how you checked.
 - Build every backend a file touches (CUDA, HIP, SYCL) before asking for review.
 - Change a default only where you measured it faster, and show the numbers with what they were measured on.
+- Never submit measurements, logs or reproduction steps you did not produce. Mark a finding from reading code as
+  unconfirmed static analysis.
 - A report from hardware the maintainers do not have is welcome. Follow
  [docs/COMMUNITY_BENCHMARKS.md](docs/COMMUNITY_BENCHMARKS.md), compare against a same-day run of the build you are
  testing, and say what you did not test.
@@ -2,6 +2,7 @@
 rem Benchmark this Strata install the way it is used and write a report you can share (docs/COMMUNITY_BENCHMARKS.md).
 rem It starts the model with your settings (or uses the one already running), takes about 10 minutes and changes nothing.
 rem Options: --clients 4 (several requests at once), --long (a 32K prompt), --compare <older results folder>.
+rem This is the quick speed check. The standard benchmark (docs/BENCHMARK_PROTOCOL.md), whose results other people can compare with, is `strata bench run`.
 setlocal
 title Strata - benchmark
 cd /d "%~dp0"
@@ -10,6 +11,8 @@ if not exist ".venv\Scripts\python.exe" (
  pause
  exit /b 1
 )
+echo  Quick speed check. For results other people can compare with (the standard benchmark, a few minutes), run: .venv\Scripts\python.exe strata.py bench run
+echo.
 ".venv\Scripts\python.exe" tools\strata_bench.py %*
 set "RC=%ERRORLEVEL%"
 pause
@@ -0,0 +1,122 @@
+# Contributing to Strata
+
+**AI assistance is welcome. The contributor is responsible for understanding the change and supplying real evidence.**
+
+These rules apply to issues, pull requests, benchmark reports, and the agents helping prepare them.
+You should be able to explain every changed line and answer review questions about it.
+
+## Before starting
+
+1. Search [issues](https://github.com/Niko1221/Strata/issues) and
+   [pull requests](https://github.com/Niko1221/Strata/pulls), including closed discussions. Add new evidence to an
+   existing thread when it covers your problem.
+2. Read [AGENTS.md](AGENTS.md) and the documentation for the component you want to change.
+3. Get maintainer agreement on scope before substantial features, refactors, architecture changes, or changes to
+   defaults. Describe the user problem, proposed behavior, and tradeoffs in an issue first. Agreement on scope
+   does not guarantee a merge. Focused fixes and benchmark reports can go straight to a PR.
+4. Keep one problem per PR. Update that PR after feedback; do not open competing attempts for the same change.
+
+Do not resubmit a declined proposal under a different title or through another agent. If new evidence changes
+the situation, bring it to the original discussion and let a maintainer decide whether to reopen it.
+
+## Report a problem people can investigate
+
+Use the matching [issue form](https://github.com/Niko1221/Strata/issues/new/choose). A bug report should include:
+
+- The smallest steps or command that reproduce the problem, and the expected and actual behavior.
+- Strata version or commit, OS, GPU and VRAM, and relevant model, quantization, and configuration.
+- The exact error and relevant logs, with credentials and private content removed.
+- Whether you reproduced it yourself. Label a finding based only on reading code or a scanner as
+  **unconfirmed static analysis**, and explain the suspected path without presenting it as an observed failure.
+
+Do not invent reproduction steps, errors, affected hardware, or severity. If you cannot reproduce something,
+say what you inspected and what would verify the hypothesis. Feature requests should explain a concrete user
+need and the current workaround. Questions should say what you tried and where you got stuck.
+
+Example structure, with placeholders to replace with actual observations:
+
+```text
+Problem: <one observed behavior>
+Environment: <commit, OS, GPU/VRAM, model/quant, relevant settings>
+Reproduce: <exact command or short sequence>
+Expected: <documented or intended behavior>
+Actual: <observed behavior and exact error>
+Evidence: <sanitized log attachment>
+Reproduction status: <reproduced locally OR unconfirmed static analysis>
+```
+
+## Titles
+
+Every issue and pull request title starts with its area in square brackets, then a short description: `[Engine]`, `[GUI]`, `[TUI]`,
+`[Benchmark]`, `[Docs]` or `[Other]`. For example `[Engine] fix decode stop on long prompts` or `[GUI] keep the model list after a tab
+switch`. The issue forms ask for the area and a check on the title fails when the prefix is missing.
+
+## Prepare a focused pull request
+
+Lead with the problem and resulting behavior. Explain why the approach is needed, the important limits, and
+any compatibility effects. Link the issue and scope agreement when applicable. A file-by-file narration or
+an AI-generated summary of the diff is not a substitute for this explanation.
+
+- Keep unrelated formatting, cleanup, dependency changes, and speculative abstractions out of the PR.
+- Add documentation where it changes what a user or developer needs to know. Avoid repeated summaries,
+  speculative roadmaps, and generated documentation with no actionable information.
+- Preserve existing behavior outside the intended change. New features are opt-in; follow the default-path
+  and performance requirements in [AGENTS.md](AGENTS.md).
+- Read the complete diff, including generated files, before submitting. Remove debugging output, secrets,
+  private paths, and accidental files.
+- Prefer a small relevant regression check over tests that only restate the implementation. Documentation-only
+  changes need link, example, and consistency checks; they do not require GPU builds.
+
+## Show the validation you actually performed
+
+List exact commands, the revision and environment tested, and observed outcomes. Keep **passed**, **failed**,
+and **not run** separate. Include relevant output or a log attachment. A command you suggest running is not
+evidence that it passed; a CI run on a different revision is not validation of the submitted code.
+
+Build every backend a code change touches, including CUDA, HIP, and SYCL where applicable, before requesting
+review. For changes that need hardware execution, report that execution separately from compilation. A mock,
+static check, or successful build does not establish hardware correctness. If you lack a required environment,
+keep the PR as a draft, identify the missing checks, and ask for targeted help in the same thread. Do not claim
+compatibility you have not tested.
+
+Performance claims need before/after runs on the same hardware and workload, with every changed setting
+identified. Preserve the individual runs, failures, and variability. Follow the
+[community measurement guide](docs/COMMUNITY_BENCHMARKS.md); standard submissions will use the
+[benchmark protocol](docs/BENCHMARK_PROTOCOL.md) once it is activated. One fast run does not justify changing a
+default or claiming a speedup for other machines.
+
+Example PR body; placeholders are not test results:
+
+```text
+Problem and result: <trigger; behavior before and after the change>
+Related discussion: <issue URL and scope agreement, when required>
+Approach: <why this fix; relevant compatibility effects>
+Validation:
+  Passed: <exact command, revision/environment, observed result, log>
+  Failed: <exact command and failure, or none observed>
+  Not run: <check, reason, and what remains unverified>
+Limits: <known limitations or remaining work>
+```
+
+## Rules for AI-assisted work
+
+Use agents to help investigate, implement, and explain work that you can review. Before submitting, verify
+their claims against the source, actual command output, or a cited primary reference.
+
+Never submit fabricated measurements, invented test results, fake logs, or copied claims you have not checked.
+Do not turn a repository scan into a batch of speculative issues or PRs. Consolidate related findings, establish
+their effect, and submit the useful evidence. Do not present an agent's confidence or another model's approval
+as validation. Keep review replies concise and address the requested change or evidence directly.
+
+Maintainers may request a smaller change, return a PR to draft, or close a submission that lacks evidence,
+duplicates existing work, or ignores agreed scope. A smaller, understandable contribution with honest limits
+is easier to review and maintain.
+
+## Share a benchmark
+
+A results-only PR should contain the human report, raw measurements, sanitized configuration, and supporting
+logs. Keep it separate from engine changes and include poor results and failed requests.
+
+The [current community benchmark guide](docs/COMMUNITY_BENCHMARKS.md) remains available for measurements made
+with today's tools. The [new protocol](docs/BENCHMARK_PROTOCOL.md) defines the draft standard and future approval
+workflow. Its draft status must remain visible: existing reports are not automatically standard or approved.
@@ -1,119 +1,112 @@
-# syntax=docker/dockerfile:1
+# Strata, built FROM SOURCE (NVIDIA CUDA 13). The engine is compiled here, packaged as an engine component package and then
+# installed into the same runtime image as the ready-made ones (docker/Dockerfile): same Terminal, same entrypoint, same /data volume.
 #
-# Strata: Qwen3.8-Flash-Next on NVIDIA GPUs (RTX 30/40/50, 12+ GB VRAM; two or
-# three cards can share one model, 8 GB each - docs/MULTI_GPU.md).
+# Most people want the ready-made images instead (nothing compiled): docs/DOCKER.md.
 #
-# The engine is compiled during docker build, so the first container start only
-# downloads the model (~70 GB) and starts the server. docker build has no GPU,
-# so the CUDA architectures are fixed here instead of read from nvidia-smi: the
-# engine is a fat binary with a cubin per listed arch, and the runtime picks the
-# one matching your card. Narrow CUDA_ARCHITECTURES to your card for a faster
-# build; a card outside the set needs a rebuild with its own arch.
+#   docker build -t strata:src .                                        # RTX 20/30/40/50 (compiles for each, ~25 min)
+#   docker build -t strata:src --build-arg CUDA_ARCHITECTURES=86 .      # one card only (faster); 86 = RTX 30, 89 = RTX 40, 120 = RTX 50
+#   docker build -t strata:src-cuda12 --build-arg CUDA_IMAGE=nvidia/cuda:12.9.1-devel-ubuntu24.04 \
+#              --build-arg CUDA_ARCHITECTURES="60;61;70;75;80;86;89" --build-arg BUILD_VISION=0 .   # GTX 10 / P100 / V100 (driver 575+)
+#   docker run --rm --gpus all -p 127.0.0.1:8080:8080 --ulimit memlock=-1 --shm-size 2g --stop-timeout 120 \
+#              -v strata-data:/data -e MODEL=IQ3_XXS -e API_KEY=change-me-please-123 strata:src
 #
-# Build:
-#   docker build -t strata .
-#   docker build -t strata --build-arg CUDA_ARCHITECTURES=89 .        # RTX 40 only
+# docker build has no GPU, so the CUDA architectures are given here instead of read from nvidia-smi. The engine is a fat binary with
+# a machine-code part per listed architecture (plus PTX for the newest, which later cards can JIT), and the runtime picks the one
+# matching your card. Narrow CUDA_ARCHITECTURES to your card for a faster build. Native code for the CPU that builds the image is NOT
+# used (STRATA_PORTABLE=ON), so the image runs on any x86-64 CPU with AVX2.
 #
-# Run (host needs an NVIDIA driver >= 580 and nvidia-container-toolkit):
-#   docker run --rm --gpus all \
-#     -p 8080:8080 \
-#     --ulimit memlock=-1 \
-#     -v strata-data:/data \
-#     -e MODEL=IQ2_XS \
-#     strata
-#
-# Setup choices are env vars, read by docker-entrypoint.sh: FAMILY, MODEL, CONTEXT,
-# VISION (no | yes | cpu), KV (int8 | q4_0 | k8v4), GPU (one card) or GPUS ("0,2"
-# or "all", with LAYER_SPLIT), LOW_RAM (auto | on | off), HOST, PORT, API_KEY,
-# GGUF_DIR (GGUF files you already have), RESIDENT_BUDGET_GIB, KV_STREAMING.
-#
-# Only the model files, the prepared pack, the MTP layer and the install config
-# live in the /data volume; the engine is part of the image. Strata loads 32-62 GB
-# into RAM, so a capped container needs -e LOW_RAM=on: setup.py reads the RAM from
-# /proc/meminfo, which here is the host's total, not the container's limit. Add an
-# API key before exposing the port to a network: -e API_KEY=<secret>. Pass
-# -e REINSTALL=1 to change the model settings later.
-#
-# --gpus all on a host with two usable cards: setup takes both (the layer split is
-# its recommended default). Pin one card with -e GPU=0, or name them with
-# -e GPUS=0,2. A volume set up for one card switches to the pair on its first start
-# on a two-card host unless GPU or GPUS pins it. LOW_RAM=on runs on one card.
+# Plain legacy-builder features only (no heredocs, no --mount). AMD (HIP) and Intel (SYCL) source builds: docs/AMD_HIP.md, docs/INTEL.md.

-FROM nvidia/cuda:13.0.0-devel-ubuntu24.04
-
-# STRATA_EXECV=1: setup.py replaces itself with the server, so the server is PID 1
-# and docker stop's SIGTERM reaches it (see setup.start). Normal Linux starts, which
-# don't set it, keep spawning the server as a child.
-ENV DEBIAN_FRONTEND=noninteractive PYTHONUNBUFFERED=1 LANG=C.UTF-8 STRATA_EXECV=1
+ARG CUDA_IMAGE=nvidia/cuda:13.0.0-devel-ubuntu24.04
+ARG RUNTIME_BASE=ubuntu:24.04

+# ---- 1. compile the engine and make its component package
+FROM ${CUDA_IMAGE} AS engine-build
+ENV DEBIAN_FRONTEND=noninteractive PYTHONUNBUFFERED=1 PATH=/venv/bin:$PATH
 RUN apt-get update && apt-get install -y --no-install-recommends \
-        build-essential ca-certificates curl git libatomic1 libgomp1 \
-        python3 python3-pip python3-venv unzip \
+        build-essential ca-certificates git libgomp1 libatomic1 python3 python3-pip python3-venv unzip \
    && rm -rf /var/lib/apt/lists/*
-
-WORKDIR /opt/strata
+WORKDIR /src
 COPY . .
-
-# RTX 20 (75), RTX 30 (86), RTX 40 (89), RTX 50 (120), plus 80 for A-series. CMakeLists
-# refuses anything below 75. BUILD_VISION=0 skips the image encoder build.
-ARG CUDA_ARCHITECTURES=75;80;86;89;120
+ARG CUDA_ARCHITECTURES="75;80;86;89;120"
 ARG BUILD_VISION=1
+ARG ENGINE_VERSION=
+RUN python3 -m venv /venv && /venv/bin/pip install --no-cache-dir -r requirements.txt -r requirements-build.txt
+# llama.cpp at the pinned commit (ggml for the engine, mtmd for pictures), exactly as setup.py fetches it
+RUN /venv/bin/python -c "import setup; print(setup.get_llama_cpp())"
+RUN set -e; \
+    real=""; for a in $(echo "$CUDA_ARCHITECTURES" | tr ';,' '  '); do real="$real;${a}-real"; done; real=${real#;}; \
+    last=$(echo "$CUDA_ARCHITECTURES" | tr ';,' '  ' | awk '{print $NF}'); \
+    sm60=OFF; for a in $(echo "$CUDA_ARCHITECTURES" | tr ';,' '  '); do if [ "$a" -lt 75 ]; then sm60=ON; fi; done; \
+    /venv/bin/cmake -G Ninja -S . -B build -DCMAKE_BUILD_TYPE=Release -DSTRATA_ENABLE_CUDA=ON -DSTRATA_BUILD_TESTS=OFF \
+        -DSTRATA_EXPERIMENTAL_SM60=$sm60 \
+        -DSTRATA_NATIVE_EXPERTS=ON -DSTRATA_PORTABLE=ON -DSTRATA_Q6K_EXPERTS=ON -DSTRATA_MMQ_KQUANTS=ON \
+        "-DCMAKE_CUDA_ARCHITECTURES=${real};${last}-virtual" -DSTRATA_GGML_DIR=/src/third_party/llama.cpp; \
+    /venv/bin/cmake --build build --target strata strata_kq -j "$(nproc)"; \
+    if [ "$BUILD_VISION" = "1" ]; then \
+      /venv/bin/cmake -G Ninja -S tools/vision -B build-vision -DCMAKE_BUILD_TYPE=Release -DLLAMA_DIR=/src/third_party/llama.cpp \
+          -DSTRATA_VISION_CUDA=ON -DSTRATA_PORTABLE=ON -DGGML_CUDA_NCCL=OFF "-DCMAKE_CUDA_ARCHITECTURES=${real};${last}-virtual"; \
+      /venv/bin/cmake --build build-vision --target strata-vision -j "$(nproc)"; \
+    fi
+RUN set -e; \
+    mkdir -p /stage /engine; \
+    cp build/strata /stage/; \
+    [ -f build/libstrata_kq.so ] && cp build/libstrata_kq.so /stage/ || true; \
+    [ -f build-vision/bin/strata-vision ] && cp build-vision/bin/strata-vision /stage/ || true; \
+    ver="${ENGINE_VERSION:-$(sed -n 's/^[[:space:]]*project([^)]*VERSION[[:space:]]*\([0-9][0-9.]*\).*/\1/p' CMakeLists.txt | head -1)}"; \
+    cudafull=$(nvcc --version | sed -n 's/.*release \([0-9][0-9]*\.[0-9][0-9]*\).*/\1/p' | head -1); cudamajor=${cudafull%%.*}; \
+    if [ "$cudamajor" = 13 ]; then mindriver=580.65; else mindriver=575.51; fi; \
+    vision_archs=""; [ -f /stage/strata-vision ] && vision_archs=", \"vision_archs\": \"$CUDA_ARCHITECTURES\""; \
+    echo "{\"version\": \"$ver\", \"source\": \"docker build\", \"archs\": \"$CUDA_ARCHITECTURES\", \"cuda\": \"$cudafull\", \"portable\": true${vision_archs}}" > /stage/BUILD.json; \
+    python3 packaging/collect_libs.py --binary build/strata --search /usr/local/cuda/lib64 --out /stage --also 'libcublasLt.so*'; \
+    archs=""; for a in $(echo "$CUDA_ARCHITECTURES" | tr ';,' '  '); do archs="$archs --arch sm_$a"; done; \
+    last=$(echo "$CUDA_ARCHITECTURES" | tr ';,' '  ' | awk '{print $NF}'); \
+    python3 packaging/package_engine.py --src /stage --backend cuda --version "$ver" --out /engine $archs --arch "compute_$last" \
+        --min-driver nvidia=$mindriver --variant cuda$cudamajor --platform linux-x86_64 --build-id "docker-source-${ver}-cuda${cudafull}" --include SYSTEM-LIBS.txt --include 'libstrata_kq*' \
+        --include strata-vision; \
+    for d in /engine/*/; do python3 packaging/package_engine.py --verify "$d"; python3 packaging/binary_deps.py "$d"; done

-RUN python3 -m venv .venv \
-    && .venv/bin/pip install --no-cache-dir --upgrade pip \
-    && .venv/bin/pip install --no-cache-dir -r requirements.txt \
-    && chmod +x setup.sh docker-entrypoint.sh
-
-# llama.cpp at the pinned commit, then the engine and the image encoder, built
-# exactly the way setup.py builds them: native code for the CPU that builds the
-# image, so build it on the PC it runs on. BUILD.json is what setup.py reads to
-# decide whether an engine is current: source=local with a matching src hash
-# means the first start reuses it instead of recompiling.
-RUN .venv/bin/python - <<'PYEOF'
-import json, os, pathlib, shutil
-import setup
-
-llama = setup.get_llama_cpp()
-nvcc, _ = setup.find_nvcc()
-arch = os.environ.get("CUDA_ARCHITECTURES", "75;80;86;89;120").strip().strip('"').replace(",", ";")
-vision = "gpu" if os.environ.get("BUILD_VISION", "1") == "1" else "none"
-
-setup.cmake_build(setup.ROOT, setup.ROOT / "build", "strata",
-    ["-DSTRATA_ENABLE_CUDA=ON", "-DSTRATA_Q6K_EXPERTS=ON", "-DSTRATA_MMQ_KQUANTS=ON", "-DSTRATA_BUILD_TESTS=OFF",
-     f"-DCMAKE_CUDA_ARCHITECTURES={arch}", f"-DCMAKE_CUDA_COMPILER={nvcc}",
-     f"-DSTRATA_GGML_DIR={llama}"], None, "build-strata.bat")
-if vision != "none":
-    setup.cmake_build(setup.ROOT / "tools" / "vision", setup.ROOT / "build-vision", "strata-vision",
-        [f"-DLLAMA_DIR={llama}", "-DSTRATA_VISION_CUDA=ON", "-DSTRATA_PORTABLE=OFF",
-         f"-DCMAKE_CUDA_ARCHITECTURES={arch}", f"-DCMAKE_CUDA_COMPILER={nvcc}"], None, "build-vision.bat")
-
-eng = setup.ROOT / "engine"
-eng.mkdir(exist_ok=True)
-shutil.copy2(setup.ROOT / "build" / setup.EXE, eng / setup.EXE)
-if (setup.ROOT / "build" / setup.KQ_LIB).exists():      # the K-quant MMQ prompt library (UD-Q4/Q5/Q6_K_XL files)
-    shutil.copy2(setup.ROOT / "build" / setup.KQ_LIB, eng / setup.KQ_LIB)
-if vision != "none":
-    shutil.copy2(setup.ROOT / "build-vision" / "bin" / setup.VEXE, eng / setup.VEXE)
-bindir = pathlib.Path(nvcc).parent
-meta = {"source": "local", "version": setup.source_version(),
-        "archs": [int(a.split("-")[0]) for a in arch.split(";") if a.split("-")[0].isdigit()], "vision": vision,
-        "cuda_dirs": [str(d) for d in (bindir, bindir / "x64", bindir.parent / "lib64") if d.is_dir()],
-        "src": setup.source_hash(setup.ENGINE_SOURCES),
-        "vision_src": setup.source_hash(setup.VISION_SOURCES) if vision != "none" else None}
-(eng / "BUILD.json").write_text(json.dumps(meta, indent=1))
-PYEOF
-
-# the cmake trees are build-time only; the engine itself is what the container needs
-RUN rm -rf build build-vision
+# ---- 2. the Terminal (the release archive, built here)
+FROM ${RUNTIME_BASE} AS terminal
+ARG STRATA_COMMIT=
+ENV STRATA_BUILD_COMMIT=${STRATA_COMMIT}
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y --no-install-recommends python3 ca-certificates git && rm -rf /var/lib/apt/lists/*
+COPY . /src/
+RUN python3 /src/packaging/package_terminal.py --out /out --cache /cache \
+ && mkdir -p /opt/strata \
+ && tar -xzf /out/strata-terminal-*-linux-x86_64.tar.gz -C /opt/strata \
+ && mv /opt/strata/strata-terminal-* /opt/strata/terminal \
+ && /opt/strata/terminal/bin/strata --version
+# llama.cpp at the commit setup.py pins: fetched here, so the first start does not depend on GitHub. Only gguf-py (the model preparation
+# tools) and the file setup.py looks for (ggml/CMakeLists.txt) are kept: 170 MB become a few
+RUN cd /opt/strata/terminal && STRATA_CONTROL_INSTALL=1 STRATA_INSTALL_DIR=/opt/strata/seed PYTHONNOUSERSITE=1 \
+      /opt/strata/terminal/python/bin/python3 -c "import setup; print(setup.get_llama_cpp())" \
+ && rm -rf /opt/strata/seed/third_party/*.zip* \
+ && cd /opt/strata/seed/third_party/llama.cpp \
+ && find . -mindepth 1 -maxdepth 1 ! -name gguf-py ! -name ggml ! -name 'LICENSE*' -exec rm -rf {} + \
+ && find ggml -mindepth 1 -depth ! -type d ! -name CMakeLists.txt -delete && find ggml -mindepth 1 -type d -empty -delete \
+ && du -sh /opt/strata/seed

+# ---- 3. the runtime image (the same as docker/Dockerfile's, FLAVOR=cuda)
+FROM ${RUNTIME_BASE}
+ARG STRATA_VERSION=dev
+ENV DEBIAN_FRONTEND=noninteractive
+RUN apt-get update && apt-get install -y --no-install-recommends tini ca-certificates libgomp1 libatomic1 libnuma1 zlib1g \
+    && rm -rf /var/lib/apt/lists/* /var/cache/apt/*
+COPY --from=terminal /opt/strata/terminal /opt/strata/terminal
+COPY --from=terminal /opt/strata/seed /opt/strata/seed
+COPY --from=engine-build /engine/ /opt/strata/components/engine/
+COPY docker/entrypoint.sh docker/healthcheck.sh /opt/strata/
+COPY docker/strata-wrapper.sh /usr/local/bin/strata
+RUN chmod 0755 /opt/strata/entrypoint.sh /opt/strata/healthcheck.sh /usr/local/bin/strata
+ENV STRATA_COMPONENTS_DIR=/opt/strata/components STRATA_INSTALL_DIR=/data/install XDG_STATE_HOME=/data/state \
+    XDG_CONFIG_HOME=/data/config HOME=/data/home PORT=8080 LANG=C.UTF-8 PYTHONUNBUFFERED=1 PYTHONNOUSERSITE=1 STRATA_IN_DOCKER=1 \
+    NVIDIA_VISIBLE_DEVICES=all NVIDIA_DRIVER_CAPABILITIES=compute,utility
 VOLUME ["/data"]
 EXPOSE 8080
-
-# /health is answered before the API key gate, so it works with or without one.
-# The port only opens after the model loads (1-3 minutes, longer on a first run),
-# so the start period is generous: a too short one marks a still-loading container
-# unhealthy and a restart policy would kill it mid-download.
-HEALTHCHECK --interval=30s --timeout=5s --start-period=600s --retries=3 \
-  CMD curl -fs "http://127.0.0.1:${PORT:-8080}/health" || exit 1
-
-ENTRYPOINT ["./docker-entrypoint.sh"]
+LABEL org.opencontainers.image.title="Strata" com.strata.flavor="cuda" com.strata.build="from-source" org.opencontainers.image.version="${STRATA_VERSION}"
+HEALTHCHECK --interval=30s --timeout=8s --start-period=2h --retries=3 CMD ["/opt/strata/healthcheck.sh"]
+STOPSIGNAL SIGTERM
+ENTRYPOINT ["/usr/bin/tini", "--", "/opt/strata/entrypoint.sh"]
+CMD ["run"]
@@ -1,239 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · **Deutsch** · [Français](README.fr.md) · [Español](README.es.md) · [Português](README.pt-BR.md)
+<h3 align="center">Leistungsstarke KI auf deinem eigenen Computer.</h3>
+<p align="center">Chatten, programmieren und mit Bildern arbeiten, lokal.</p>

-<p align="center"><b>Ein KI-Modell mit 125 Milliarden Parametern auf deinem eigenen Gaming-PC</b><br>
-NVIDIA- oder AMD-Grafikkarte (ab 12 GB) · Windows oder Linux · kostenlos und Open Source</p>
+<p align="center">
+  <a href="#modelle">Modelle</a> · <a href="#installation"><b>Installation</b></a> ·
+  <a href="#hardware">Hardware</a> · <a href="#tools">Tools</a> ·
+  <a href="#hilfe">Hilfe</a> · <a href="#strata-unterstützen">Unterstützen</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Ein Voxel-Pagodengarten, den das Modell in Strata geschrieben hat, läuft im Browser"></a><br>
-<sub>Ein Voxel-Pagodengarten aus einem einzigen Prompt, auf einer RTX 5070 mit Strata (IQ3_S, 128K Kontext) ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">ganzes Video (49 s)</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Strata herunterladen"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="MIT-Lizenz"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Strata auf Buy Me a Coffee unterstützen"></a>
+</p>

-Strata lässt **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** auf einem normalen PC laufen.
-Das ist ein großes, kluges KI-Modell, das sonst meist einen Server braucht. Es chattet, schreibt Code, versteht
-Bilder und arbeitet mit deinen Apps und Coding-Agents zusammen. Nichts verlässt deinen PC.
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <b>Deutsch</b> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## Wie schnell ist es?
+**Kostenlos, Open Source und ganz in deiner Hand.** Nutze Strata auf dem Desktop oder mit deinen liebsten Coding-Tools. Kein Konto nötig.

-Wir haben es auf zwei ganz normalen Gaming-PCs gemessen. Ein Token ist etwa ¾ eines Wortes.
+## Modelle

- **Schreibt Antworten:** wie schnell die Antwort in einem kurzen Chat erscheint. 60 Tokens pro Sekunde sind
-  schneller, als du lesen kannst.
- **Liest deinen Prompt:** wie schnell es aufnimmt, was du schickst (hier ein Dokument, Code oder Chatverlauf mit
-  32K Tokens).
+Wir empfehlen **zuerst ISTA-DASLab**, danach **Unsloth** und andere Anbieter, soweit ein passendes Modell in deinen Speicher passt.

-<table>
-<tr><th>NVIDIA: RTX 5070 (12 GB), Ryzen 5 7600, 64 GB RAM</th><th>AMD: RX 9070 XT (16 GB), Ryzen 9 3900X, 47 GB RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| Größe | Schreibt Antworten | Liest deinen Prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 94 Tokens/s | 2,650 Tokens/s |
-| **IQ2_XS** | 79 Tokens/s | 2,090 Tokens/s |
-| **IQ3_XXS** | 62 Tokens/s | 1,750 Tokens/s |
-| **IQ3_S** | 53 Tokens/s | 1,620 Tokens/s |
-| **Coder** | 55 Tokens/s | 2,180 Tokens/s |
-
-</td><td>
-
-| Größe | Schreibt Antworten | Liest deinen Prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 60 Tokens/s | 1,160 Tokens/s |
-| **IQ2_XS** | 52 Tokens/s | 1,110 Tokens/s |
-| **Coder** | 44 Tokens/s | 1,420 Tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA: Q2_0 mit Engine 0.1.36, die anderen Zeilen mit 0.1.26 (4K Antworten, 32K Prompts). Die vollständigen
-Tabellen stehen in [DETAILS.md](docs/DETAILS.md#speed-measured). Eine Karte mit mehr VRAM ist schneller: Eine
-RTX 3090 (24 GB) sollte etwa 100-140 Tokens pro Sekunde schreiben. Lange Chats und andere Karten:
-[Tempo jedes Modells](docs/MODELS.md#how-fast-is-each-size), [Ergebnisse aus der Community](docs/COMMUNITY_BENCHMARKS.md).
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>Strata ist kostenlos. Wenn es auf deinem PC gut läuft, hält ein Kaffee die Arbeit daran am Laufen.</sub></p>
-
-## Was du brauchst
-
-| | |
+| Anbieter | Auswahl |
 | --- | --- |
-| **Grafikkarte** | **NVIDIA** GeForce RTX 20, 30, 40 oder 50 Serie, oder **AMD** Radeon RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT, Radeon AI PRO R9700 oder RX 6800 / 6900 Serie. Sie braucht **12 GB VRAM oder mehr**. |
-| **RAM** | 32 GB oder mehr. Dein RAM entscheidet, [welches Modell](#welches-modell-soll-ich-nehmen) passt. Mit 64 GB laufen alle Größen. |
-| **Festplatte** | Etwa 80 GB frei. Nimm wenn möglich eine SSD: Der erste Start geht dann viel schneller. |
-| **System** | Windows 10 / 11 oder Linux und ein aktueller Grafiktreiber von NVIDIA oder AMD. |
+| **ISTA-DASLab · empfohlen** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder: IQ1\_M](docs/MODELS.md#coder) zum Programmieren. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Geringerer Speicherbedarf, aber langsamer. |
+| **Weitere Optionen** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-Alles andere richtet der Installer ein. Zwei oder drei Karten können sich das Modell teilen ([Multi-GPU](docs/MULTI_GPU.md)).
+[Größen, Speicherbedarf und Kompatibilität vergleichen](docs/MODELS.md).

-Experimentell, von Community-Mitgliedern auf ihren eigenen Rechnern geschrieben und getestet:
+</details>

- **Ältere Grafikkarten** (Tesla P40 / V100, GTX 10, Radeon VII / MI50, RX 6700 XT, RX 5500 XT): [Ältere GPUs](docs/OLDER_GPUS.md).
- **Intel Arc**, unter Linux aus dem Quellcode gebaut: [Intel Arc](docs/INTEL_ARC.md).
- **AMD Ryzen AI Max (Strix Halo)**, unter Linux aus dem Quellcode gebaut: [Strix Halo](docs/STRIX_HALO.md).
- **Ältere Prozessoren ohne AVX2**: Sie funktionieren, aber langsam. [Ältere CPUs](docs/INSTALL.md#older-cpus-experimental).
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-Die vollständige Liste: [docs/INSTALL.md](docs/INSTALL.md#what-you-need).
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. Das sind die derzeit dokumentierten Pakete für dieses Modell.

-## Installieren
+[Modellanleitung und Kompatibilität](docs/QWEN36.md).

-### Lass deine KI es einrichten
+</details>

-Nutzt du einen KI-Coding-Assistenten (Claude Code, Cursor, Codex, GitHub Copilot, ...)? Füge dort diesen Text ein:
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+In der **Desktop-App** und im **Terminal**. Was nicht in den Arbeitsspeicher passt, wird von deiner SSD gelesen. Darum brauchst du viel freien Speicherplatz.
+
+| Set (IST-DAS) | Download | Freier Speicherplatz nötig |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | etwa 245 GB |
+| 2.00 bpw | 257 GB | etwa 265 GB |
+| 2.25 bpw | 274 GB | etwa 280 GB |
+
+Läuft auf NVIDIA RTX 30, 40 und 50 (Windows und Linux) und auf AMD Radeon AI PRO R9700 (Linux). Das Setup lädt die Dateien und die DeepSeek-Engine herunter und startet dann das Modell.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
 ```

-Er prüft deine Grafikkarte, deinen RAM und deine Festplatte und wählt das passende Modell. Dann installiert und
-startet er es und sagt dir, wie du deine Apps verbindest. KI-Tools können Strata auch über seinen
-[MCP-Server](docs/MCP_SERVER.md) installieren, starten und stoppen.
+Gemessen mit dem 2.00-bpw-Set auf Strata 0.2.5. „Ausgabe“ ist das Tempo der Antwort, „Prompt“ zeigt, wie schnell Strata deine Eingabe liest.

-### Oder mach es selbst
+| Hardware | Ausgabe | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB RAM | 4 bis 6 Token/s | etwa 110 Token/s (4K) |
+| RTX 3060 12 GB, 46 GB RAM | 9 bis 11 Token/s | etwa 155 Token/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB RAM | 21 bis 25 Token/s | 320 bis 360 Token/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 bis 77 Token/s | 400 bis 450 Token/s (8K) |

-[Lade Strata herunter](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) und entpacke es (oder nutze
-`git clone`). **Windows:** Doppelklick auf **`START-HERE.bat`**. **Linux:** Führe im Strata-Ordner **`./setup.sh`** aus.
+[Speicher, Festplatte und Details](docs/DEEPSEEK41.md) · [Versionshinweise](https://github.com/Niko1221/Strata/releases)

-**Mac (Apple Silicon, M1 bis M5, macOS 15 oder neuer):** Installiere einmal Apples Command Line Tools (`xcode-select --install` im Terminal; Xcode selbst brauchst du nicht). Öffne dann das Terminal im Strata-Ordner und führe **`./setup.sh`** aus. Es baut die Mac-Engine auf deinem Mac (etwa 7 Minuten), stellt dieselben Fragen, lädt das Modell und startet es. Beim nächsten Mal startet `./setup.sh` sofort. Welche Größe zu deinem Mac passt und wie schnell es ist: [docs/MAC.md](docs/MAC.md).
+</details>

-Die Schritte sind für NVIDIA und AMD gleich. Der Installer erkennt deine Karte und richtet die passende Engine
-dafür ein. Er stellt dir ein paar Fragen:
+<a id="the-other-sizes"></a>

- welches Modell und welche Größe,
- wie viel Kontext (wie viel Text sich das Modell merkt),
- ob es Bilder lesen soll.
+Unsicher, was passt? [Wähle ein Modell für deinen Computer](docs/MODELS.md#pick-by-memory).

-Drück jedes Mal Enter, um die empfohlene Antwort zu nehmen. Dann lädt er das Modell herunter (etwa 70 GB) und
-startet es. Bricht der Download ab, starte ihn einfach neu: Er macht dort weiter, wo er aufgehört hat. Dein Browser
-öffnet die Strata-App unter `http://127.0.0.1:8080`.
+## Installation

-> **Während das Modell startet, kann dein PC 1-3 Minuten langsam sein oder nicht reagieren** (beim ersten Mal am
-> längsten). Strata lädt 35-55 GB in deinen RAM und reserviert einen Teil davon für die Grafikkarte. Das ist normal.
-> Warte und schließ das Fenster nicht. Im Fenster siehst du, was Strata gerade tut.
+<a id="option-a-the-strata-app"></a>

-**Beim nächsten Mal** startest du wieder `START-HERE.bat` (oder `./setup.sh`). Es startet sofort und lädt nichts
-doppelt herunter. Schließ das Fenster, um das Modell zu stoppen. `UPDATE.bat` (`./update.sh`) aktualisiert Strata,
-ohne es zu starten. Updates, Docker, mehrere Karten, wo die Dateien landen und alle Optionen:
-[docs/INSTALL.md](docs/INSTALL.md).
+### Desktop-App

-## Welches Modell soll ich nehmen?
+**[Strata für Windows, Linux oder Mac herunterladen →](https://github.com/Niko1221/Strata/releases/latest)**

-Der Installer empfiehlt eins passend zu deinem RAM. Dasselbe Modell gibt es in mehreren Größen, mehr oder weniger
-stark komprimiert. Kleinere Größen sind schneller. Größere sind etwas klüger.
+Installiere die App, wähle ein Modell und leg mit dem Chat los. Es gibt einen Installer pro System. Beim ersten Start lädt die App die Engine für deine Grafikkarte herunter. [Hilfe zum Installer](docs/INSTALL.md#the-app).

-| Dein RAM | Nimm | Warum |
-| --- | --- | --- |
-| **32 GB** | **Coder** | passt in 32 GB und ist für Code gemacht (mit einer 24-GB-Karte laufen auch Q2_0 und IQ2_XS) |
-| **48 GB** | **IQ2_XS** (oder Q2_0, das schnellste) | die größeren Größen passen nicht |
-| **64 GB** | **IQ2_XS** (empfohlen) oder IQ3_XXS / IQ3_S | alle Größen passen; IQ3_S ist das beste und das langsamste |
-| **96 GB oder mehr** | **IQ3_S** oder Unsloths UD-IQ4_XS (~4 Bit) | Platz für die größten Größen, auch wenn alles andere offen ist |
+<sub>Dateien: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>

- **[Coder](docs/MODELS.md#coder):** eine Version für Code, bei der die Hälfte der Experten entfernt wurde. Sie
-  erreicht 91 % des SWE-bench-Verified-Werts des vollen Modells (von ihren Autoren gemessen) und passt in 32 GB RAM.
-  Außerhalb von Code ist sie schwächer, auch bei chinesischem und anderem CJK-Text (#438). Nimm dafür Q2_0, IQ2_XS
-  oder IQ3_S, die alle Experten behalten.
- **[Swift 1.5](docs/MODELS.md#swift-15):** ein Fine-Tune, das viel kürzer nachdenkt, bevor es antwortet. Du
-  bekommst die Antwort früher, bei etwa gleicher Qualität.
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs):** die ~4-Bit-Version von Unsloth, in der Qualität
-  zwischen IQ3_S und UD-Q4_K_XL. 94 GB Download. Mit weniger als ~80 GB RAM liest Strata einen Teil davon während
-  der Antwort von der SSD, dort ist es also langsamer (eine NVMe-SSD hilft).
- **[Unsloth UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL und Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0):** 4 bis 8 Bit, näher am vollen Modell
-  (93-95 % das gleiche nächste Token wie Q8_0). Schnell, wenn alle Experten in den RAM passen (~88 GB für UD-Q4_K_XL
-  bis ~136 GB für Q8_0); mit weniger RAM liest Strata einen Teil davon während der Antwort von der SSD, was viel
-  langsamer ist (7-8.5 Tokens/s für UD-Q4_K_XL auf einem PC mit 64 GB).
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs):** Das richtest du von Hand
-  ein. Es steht nicht im Menü des Installers.
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Strata-Desktop-App mit Chat und Live-Codevorschau nebeneinander">
+  <br><sub>Chat, Dateien und Live-Vorschau in einem Fenster.</sub>
+</p>

-Größen, Downloads und was wohin passt: [docs/MODELS.md](docs/MODELS.md). Um später ein weiteres Modell
-hinzuzufügen, starte `SETUP.bat` (Linux: `./setup.sh --setup`).
+<a id="option-b-the-terminal-one-line"></a>

-## So benutzt du es
+### Terminal-App

-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="Der Monitor-Tab der Strata-App neben einem Coding-Agent"><br>
-<sub>Der <b>Monitor</b> der Strata-App (links), während ein Coding-Agent den Pagodengarten aus dem Video schreibt (rechts)</sub></p>
+Lieber im Terminal? Installiere Strata und starte dann **`strata launch`**.

- **Im Browser:** Öffne `http://127.0.0.1:8080`. Dort gibt es **Chat**, einen Live-**Monitor** für das Modell und
-  deine GPU/CPU/RAM und **About** mit den Einstellungen und Adressen.
- **Deine Apps und Coding-Agents:** Füge einen „OpenAI-kompatiblen“ Anbieter mit der Basis-URL
-  **`http://127.0.0.1:8080/v1`** hinzu. Jeder API-Key und jeder Modellname funktioniert.
-  - Apps, die die API von Anthropic nutzen: `http://127.0.0.1:8080/v1/messages` (Claude Code:
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`).
-  - Codex CLI und andere Apps, die die OpenAI Responses API nutzen: `/v1/responses`
-    ([Einrichtung](docs/DETAILS.md#the-responses-api-and-codex-cli)).
- **Nachdenken:** Wähle **aus, niedrig, mittel oder hoch** im Chat-Menü oder unter „Reasoning Effort“ in deiner
-  App. Aus ist am schnellsten. Hoch ist am besten für schwierige Fragen.
- **Bilder:** Antworte im Setup mit Ja auf „Images?“. Klick dann im Chat auf **Picture** oder hänge Bilder in deiner
-  App an. AMD-Karten lesen Bilder unter Linux über den Prozessor; unter Windows geht das noch nicht.
- **Vom Handy oder einem anderen PC:** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`. Setz immer einen
-  Key.
- **Eine Anfrage nach der anderen:** Standardmäßig beantwortet Strata eine Anfrage, die anderen warten. Um mehrere
-  gleichzeitig zu beantworten, setz `"parallel": 2` ([BATCHING.md](docs/BATCHING.md)). Auf einer 12-GB-Karte wird
-  dadurch jede Antwort langsamer.
- **Lange Prompts:** Strata liest die erste Nachricht eines Chats komplett, etwa 1 Minute pro 30,000 Tokens.
-  Folgenachrichten starten in Sekunden.
+<details open>
+<summary><b>Installationsbefehle</b></summary>

-Mehr: [wo deine Chats gespeichert werden](docs/INSTALL.md#where-things-are-stored), [die API](docs/DETAILS.md#using-it).
+**Linux / Mac**

-### Optional: mehr Tempo mit einer Grafikkarte, wenn das ganze Modell in den RAM passt
-
-Zwei Opt-in-Einstellungen (von RubenTorney, #1904 und #1905). Sie helfen, wenn du eine Grafikkarte nutzt und dein RAM alle Experten hält (Stratas Arena-Modus, zum Beispiel Q2_0 oder IQ3_XXS auf einem PC mit 64 GB). Öffne deine Konfiguration `strata-<model>.json` im Strata-Datenordner ([wo](docs/INSTALL.md#where-things-are-stored)) und füge hinzu:
-
- **Schnellere Ausgabe:** `"--adapt-async", "1"` in die Liste `"args"`. Der Experten-Cache wird dann in einem Hilfs-Thread aktualisiert, statt die Antwort anzuhalten. Gemessen auf einer RTX 5070 (Windows, Q2_0): +4-5 % Ausgabe, +7-10 % bei Code und langen Dokumenten. Antworten können leicht vom Standard abweichen (sie bleiben von Lauf zu Lauf gleich).
- **Schnelleres Prompt-Lesen unter Windows:** `"STRATA_PIN_BY_NEED": "1"` im Block `"env"`. Windows kann nur etwa den halben RAM für die Grafikkarte sperren; damit werden zuerst die Experten gesperrt, die die Karte wirklich braucht. Gemessen auf der RTX 5070: +4,4 % Prompt-Lesen.
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-Starte Strata danach neu (`START-HERE.bat` oder `./setup.sh`). Zum Rückgängigmachen entferne die beiden Einträge.
+**Windows PowerShell**

-## Etwas ist schiefgelaufen?
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
+```

- **Mein PC ist beim ersten Start von Strata eingefroren.** Das ist normal, während das Modell lädt. Warte und
-  schließ das Fenster nicht. Nach 10 Minuten immer noch eingefroren? Starte den PC neu, schließ andere Programme und
-  versuch es noch einmal, oder nimm eine kleinere Größe.
- **Es hat beim Herunterladen oder Installieren aufgehört.** Starte `START-HERE.bat` (oder `./setup.sh`) noch
-  einmal. Es macht dort weiter, wo es aufgehört hat.
- **Es ist sehr langsam und die Festplattenlampe blinkt ständig, oder es meldet „the engine stopped
-  unexpectedly“.** Dein PC hat nicht genug freien RAM. Schließ andere Programme (Browser brauchen viel) oder nimm
-  eine kleinere Größe (Q2_0 oder IQ2_XS).
- **Es meldet, dass Port 8080 schon belegt ist.** Strata läuft bereits. Such nach seinem Fenster.
+Öffne unter Windows danach ein neues Terminal. Dann:

-Weitere Probleme und ihre Lösungen: [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md). Kommst du nicht weiter?
-Öffne ein [Issue](https://github.com/Niko1221/Strata/issues) und hänge `strata-<model>.log` aus dem Strata-Ordner
-an. Du hast ein Sicherheitsproblem gefunden? Melde es vertraulich: [SECURITY.md](SECURITY.md).
+```sh
+strata launch
+```

-## Wie funktioniert es?
+Folge den Anweisungen, um ein Modell herunterzuladen und zu starten. [Terminal-Anleitung](docs/TERMINAL_LAUNCH.md).

-Modelle wie dieses laufen normalerweise auf Servern mit Hunderten Gigabyte Grafikspeicher. Deine Grafikkarte hat
-12-24 GB. Strata bringt das Modell trotzdem unter, indem es **die Arbeit auf deinen ganzen PC verteilt**. Stell dir
-eine Küche vor: Was du ständig brauchst, bleibt auf der Arbeitsfläche, der Rest wartet in der Vorratskammer.
+</details>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="Die 24,576 Experten des Modells: die meistgenutzten auf der Grafikkarte, alle im RAM, eine Nachschlagetabelle auf der SSD"></p>
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Strata-Terminal-App mit Modellaktivität, Tempo, Speicher und letzten Anfragen">
+  <br><sub>Behalte Modell und Hardware im Blick, während es läuft.</sub>
+</p>

- **Das Modell ist ein Team aus 24,576 kleinen Spezialisten („Experten“).** Jedes Wort braucht nur 10 davon.
- **Deine Grafikkarte** hält die paar tausend Experten, die am häufigsten gebraucht werden. **Dein RAM** hält alle,
-  und **dein Prozessor** rechnet gleichzeitig am Rest. **Deine SSD** hält eine große Nachschlagetabelle.
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="Ein kleiner Helfer rät die nächsten Wörter; das große Modell prüft alle auf einmal und behält die richtigen"></p>
+[Aus dem Quellcode bauen](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Vollständige Installationsanleitung](docs/INSTALL.md)

- **Raten, dann prüfen:** Ein kleiner Helfer rät die nächsten paar Wörter. Das große Modell prüft sie alle auf
-  einmal. Du bekommst dieselbe Antwort, nur 1.6-1.8x schneller.
- **Lange Texte werden in großen Stücken gelesen** (bis zu 8,192 Tokens auf einmal), mit über 1,000 Tokens pro
-  Sekunde.
+<a id="what-you-need"></a>

-Die längere Erklärung: [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md). Jeder Teil und seine Zahlen:
-[die Details](docs/DETAILS.md#how-it-works) und das [Paper](docs/paper/Strata-Paper.pdf).
+## Hardware

-## Danksagung und Lizenz
+| Unterstützte Hardware | Anleitung |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50** | [NVIDIA-Setup](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [AMD-Setup](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · experimentell** | [RX-6000-Setup](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Intel-Setup](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 oder neuer** | [Mac-Setup](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Strix-Halo-Setup](docs/STRIX_HALO.md) |

-Das Modell ist [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) vom Qwen-Team. Komprimiert
-wurde es von [ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), UkisAI (Swift 1.5)
-und Unsloth. Strata nutzt Teile von [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp). Alle Danksagungen:
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits). Strata ist Open Source unter der [MIT-Lizenz](LICENSE). Ein
-paar Teile und alle Modelle haben eigene Lizenzen ([welche](docs/HOW_IT_WORKS.md#license)).
+<a id="using-it"></a>
+
+## Tools
+
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**, und weitere über die OpenAI- und Anthropic-kompatiblen APIs.
+
+Führe **`strata connect`** aus, um die Einrichtung für dein Tool zu sehen. [Verbindungsanleitung](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## Hilfe
+
+[Alle Anleitungen](docs) · [Fehlerbehebung](docs/TROUBLESHOOTING.md) · [Fehler melden](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Benchmarks](docs/COMMUNITY_BENCHMARKS.md) · [So funktioniert es](docs/HOW_IT_WORKS.md) · [Mitmachen](CONTRIBUTING.md)

 ## Strata unterstützen

-Strata ist kostenlos und Open Source. Wenn es dir nützt, kannst du die Entwicklung unterstützen:
+**Hilf mit, lokale KI für alle offen zu halten.** Ein Kaffee hilft, Entwicklung und Tests auf mehr Hardware zu finanzieren.

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: Strata unterstützen" height="48"></a>
+
+[MIT-Lizenz](LICENSE) · [Danksagung und Modelllizenzen](docs/HOW_IT_WORKS.md#credits) · [Datenschutz](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>Für KI-Tools und automatische Leser: <a href="AGENTS.md">technische Referenz</a> · <a href="docs/AI_SETUP.md">Setup-Anleitung</a>.</sub>
+
+**Sponsoring, Hardware-Partnerschaften oder Zusammenarbeit:** [[email protected]](mailto:[email protected]).
@@ -1,233 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [Deutsch](README.de.md) · [Français](README.fr.md) · **Español** · [Português](README.pt-BR.md)
+<h3 align="center">IA potente en tu propio ordenador.</h3>
+<p align="center">Chatea, programa y trabaja con imágenes, en local.</p>

-<p align="center"><b>Ejecuta un modelo de IA de 125 mil millones de parámetros en tu propio PC gaming</b><br>
-Tarjeta gráfica NVIDIA o AMD (12 GB o más) · Windows o Linux · libre y de código abierto</p>
+<p align="center">
+  <a href="#modelos">Modelos</a> · <a href="#instalación"><b>Instalación</b></a> ·
+  <a href="#hardware">Hardware</a> · <a href="#herramientas">Herramientas</a> ·
+  <a href="#ayuda">Ayuda</a> · <a href="#apoya-strata">Apoyar</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Un jardín con una pagoda de vóxeles que escribió el modelo de Strata, funcionando en el navegador"></a><br>
-<sub>Un jardín con una pagoda de vóxeles, hecho con un solo prompt en una RTX 5070 con Strata (IQ3_S, contexto de 128K) ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">vídeo completo (49 s)</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Descargar Strata"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="Licencia MIT"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Apoya Strata en Buy Me a Coffee"></a>
+</p>

-Strata ejecuta **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** en un PC normal. Es un
-modelo de IA grande e inteligente que normalmente necesita un servidor. Conversa, escribe código, entiende imágenes
-y funciona con tus aplicaciones y agentes de programación. Nada sale de tu PC.
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <b>Español</b> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## ¿Qué velocidad tiene?
+**Gratis, de código abierto y tuyo para ejecutar.** Usa Strata en tu escritorio o con tus herramientas de programación favoritas. No necesitas cuenta.

-Lo medimos en dos PC gaming normales. Un token equivale más o menos a ¾ de una palabra.
+## Modelos

- **Escribe respuestas:** lo rápido que aparece la respuesta en un chat corto. 60 tokens por segundo es más rápido de lo que puedes leer.
- **Lee tu prompt:** lo rápido que procesa lo que le envías (aquí, un documento, código o historial de chat de 32K tokens).
+Recomendamos **primero ISTA-DASLab**, después **Unsloth** y otros proveedores, siempre que haya un modelo compatible que quepa en tu memoria.

-<table>
-<tr><th>NVIDIA: RTX 5070 (12 GB), Ryzen 5 7600, 64 GB RAM</th><th>AMD: RX 9070 XT (16 GB), Ryzen 9 3900X, 47 GB RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| Tamaño | Escribe respuestas | Lee tu prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| Tamaño | Escribe respuestas | Lee tu prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA: Q2_0 con el motor 0.1.36, las demás filas con 0.1.26 (respuestas de 4K, prompts de 32K). Las tablas
-completas están en [DETAILS.md](docs/DETAILS.md#speed-measured). Una tarjeta con más VRAM es más rápida: una
-RTX 3090 (24 GB) debería escribir unos 100-140 tokens por segundo. Chats largos y otras tarjetas:
-[velocidad de cada modelo](docs/MODELS.md#how-fast-is-each-size), [resultados de la comunidad](docs/COMMUNITY_BENCHMARKS.md).
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>Strata es gratis. Si funciona bien en tu PC, un café ayuda a seguir trabajando en él.</sub></p>
-
-## Qué necesitas
-
-| | |
+| Proveedor | Opciones |
 | --- | --- |
-| **Tarjeta gráfica** | **NVIDIA** GeForce serie RTX 20, 30, 40 o 50, o **AMD** Radeon RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT, Radeon AI PRO R9700 o serie RX 6800 / 6900. Necesita **12 GB de VRAM o más**. |
-| **RAM** | 32 GB o más. Tu RAM decide [qué modelo](#qué-modelo-elijo) cabe. Con 64 GB funcionan todos los tamaños. |
-| **Disco** | Unos 80 GB libres. Usa un SSD si puedes: el primer arranque es mucho más rápido. |
-| **Sistema** | Windows 10 / 11 o Linux, y un controlador gráfico actual de NVIDIA o AMD. |
+| **ISTA-DASLab · recomendado** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder: IQ1\_M](docs/MODELS.md#coder) para programar. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Usa menos memoria, pero es más lento. |
+| **Otras opciones** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-El instalador prepara todo lo demás. Dos o tres tarjetas pueden repartirse el modelo ([multi-GPU](docs/MULTI_GPU.md)).
+[Compara tamaños, necesidades de memoria y compatibilidad](docs/MODELS.md).

-Experimental, escrito y probado por miembros de la comunidad en sus propios equipos:
+</details>

- **Tarjetas gráficas antiguas** (Tesla P40 / V100, GTX 10, Radeon VII / MI50, RX 6700 XT, RX 5500 XT): [Older GPUs](docs/OLDER_GPUS.md).
- **Intel Arc**, compilado desde el código fuente en Linux: [Intel Arc](docs/INTEL_ARC.md).
- **AMD Ryzen AI Max (Strix Halo)**, compilado desde el código fuente en Linux: [Strix Halo](docs/STRIX_HALO.md).
- **Procesadores antiguos sin AVX2**: funcionan, pero despacio. [Older CPUs](docs/INSTALL.md#older-cpus-experimental).
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-La lista completa: [docs/INSTALL.md](docs/INSTALL.md#what-you-need).
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. Son los paquetes documentados actualmente para este modelo.
+
+[Guía del modelo y compatibilidad](docs/QWEN36.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+En la **aplicación de escritorio** y en el **Terminal**. Lo que no cabe en la memoria se lee desde tu SSD, así que hace falta mucho espacio libre en disco.
+
+| Conjunto (IST-DAS) | Descarga | Espacio libre necesario |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | unos 245 GB |
+| 2.00 bpw | 257 GB | unos 265 GB |
+| 2.25 bpw | 274 GB | unos 280 GB |
+
+Funciona en NVIDIA RTX 30, 40 y 50 (Windows y Linux) y en AMD Radeon AI PRO R9700 (Linux). La instalación descarga los archivos y el motor de DeepSeek, y después inicia el modelo.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Medido con el conjunto de 2.00 bpw en Strata 0.2.5. «Salida» es la velocidad de la respuesta; «Prompt» es la rapidez con la que Strata lee tu texto.
+
+| Hardware | Salida | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB de RAM | 4 a 6 tokens/s | unos 110 tokens/s (4K) |
+| RTX 3060 12 GB, 46 GB de RAM | 9 a 11 tokens/s | unos 155 tokens/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB de RAM | 21 a 25 tokens/s | 320 a 360 tokens/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 a 77 tokens/s | 400 a 450 tokens/s (8K) |
+
+[Memoria, disco y detalles](docs/DEEPSEEK41.md) · [Notas de la versión](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+¿No sabes qué cabe? [Elige un modelo para tu ordenador](docs/MODELS.md#pick-by-memory).

 ## Instalación

-### Deja que tu IA lo instale
+<a id="option-a-the-strata-app"></a>

-¿Usas un asistente de programación con IA (Claude Code, Cursor, Codex, GitHub Copilot, ...)? Pega esto en él:
+### Aplicación de escritorio

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[Descargar Strata para Windows, Linux o Mac →](https://github.com/Niko1221/Strata/releases/latest)**
+
+Instala la aplicación, elige un modelo y empieza a chatear. Hay un instalador por sistema. En el primer arranque, la aplicación descarga el motor para tu tarjeta gráfica. [Ayuda con el instalador](docs/INSTALL.md#the-app).
+
+<sub>Archivos: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Aplicación de escritorio de Strata con un chat y una vista previa del código en vivo, una junto a otra">
+  <br><sub>Chat, archivos y vista previa en vivo en una sola ventana.</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### Aplicación de Terminal
+
+¿Prefieres la terminal? Instala Strata y ejecuta **`strata launch`**.
+
+<details open>
+<summary><b>Comandos de instalación</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-Revisa tu tarjeta gráfica, tu RAM y tu disco, y elige el modelo que cabe. Luego lo instala, lo arranca y te explica
-cómo conectar tus aplicaciones. Las herramientas de IA también pueden instalar, arrancar y detener Strata con su
-[servidor MCP](docs/MCP_SERVER.md).
+**Windows PowerShell**

-### O hazlo tú mismo
-
-[Descarga Strata](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) y descomprímelo (o usa `git clone`).
-**Windows:** haz doble clic en **`START-HERE.bat`**. **Linux:** ejecuta **`./setup.sh`** en la carpeta de Strata.
-
-**Mac (Apple Silicon, M1 a M5, macOS 15 o posterior):** instala una vez las Command Line Tools de Apple (`xcode-select --install` en Terminal; no hace falta Xcode). Luego abre Terminal en la carpeta de Strata y ejecuta **`./setup.sh`**. Compila el motor de Mac en tu Mac (unos 7 minutos), hace las mismas preguntas, descarga el modelo y lo arranca. La próxima vez, `./setup.sh` arranca enseguida. Qué tamaño cabe en tu Mac y qué velocidad tiene: [docs/MAC.md](docs/MAC.md).
-
-Los pasos son los mismos para NVIDIA y AMD. El instalador detecta tu tarjeta y prepara el motor adecuado para ella.
-Te hace unas pocas preguntas:
-
- qué modelo y qué tamaño,
- cuánto contexto (cuánto texto tiene presente el modelo),
- si debe entender imágenes.
-
-Pulsa Enter cada vez para usar la respuesta recomendada. Después descarga el modelo (unos 70 GB) y lo arranca. Si la
-descarga se detiene, vuelve a ejecutarlo: sigue donde lo dejó. Tu navegador abre la aplicación de Strata en
-`http://127.0.0.1:8080`.
-
-> **Mientras el modelo arranca, tu PC puede ir lento o dejar de responder durante 1-3 minutos** (más la primera vez).
-> Strata carga 35-55 GB en tu RAM y reserva una parte para la tarjeta gráfica. Es normal. Espera y no cierres la
-> ventana. La ventana muestra lo que está haciendo Strata.
-
-**La próxima vez**, vuelve a ejecutar `START-HERE.bat` (o `./setup.sh`). Arranca enseguida y no descarga nada dos
-veces. Cierra su ventana para detener el modelo. `UPDATE.bat` (`./update.sh`) actualiza Strata sin arrancarlo.
-Actualizaciones, Docker, varias tarjetas, dónde se guardan los archivos y todas las opciones: [docs/INSTALL.md](docs/INSTALL.md).
-
-## ¿Qué modelo elijo?
-
-El instalador te recomienda uno según tu RAM. El mismo modelo viene en varios tamaños, más o menos comprimidos. Los
-tamaños pequeños son más rápidos. Los grandes son algo más inteligentes.
-
-| Tu RAM | Elige | Por qué |
-| --- | --- | --- |
-| **32 GB** | **Coder** | cabe en 32 GB y está hecho para programar (con una tarjeta de 24 GB también funcionan Q2_0 e IQ2_XS) |
-| **48 GB** | **IQ2_XS** (o Q2_0, el más rápido) | los tamaños más grandes no caben |
-| **64 GB** | **IQ2_XS** (recomendado), o IQ3_XXS / IQ3_S | caben todos los tamaños; IQ3_S es el mejor y el más lento |
-| **96 GB o más** | **IQ3_S**, o el UD-IQ4_XS de Unsloth (~4 bits) | espacio para los tamaños más grandes con todo lo demás abierto |
-
- **[Coder](docs/MODELS.md#coder):** una versión para programar a la que se le quitó la mitad de los expertos. Alcanza
-  el 91% de la puntuación SWE-bench Verified del modelo completo (medido por sus autores) y cabe en 32 GB de RAM. Es
-  más flojo fuera del código, también con chino y otros textos CJK (#438). Para eso, elige Q2_0, IQ2_XS o IQ3_S, que
-  conservan todos los expertos.
- **[Swift 1.5](docs/MODELS.md#swift-15):** un ajuste fino que piensa mucho menos tiempo antes de responder. Recibes
-  la respuesta antes, con más o menos la misma calidad.
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs):** la versión de ~4 bits de Unsloth, entre IQ3_S y
-  UD-Q4_K_XL en calidad. Una descarga de 94 GB. Con menos de ~80 GB de RAM, Strata lee una parte desde el SSD
-  mientras responde, así que ahí es más lento (un SSD NVMe ayuda).
- **[Unsloth UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL y Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0):** de 4 a 8 bits, más cerca del modelo completo
-  (93-95 % el mismo token siguiente que Q8_0). Rápidos cuando todos los expertos caben en la RAM (~88 GB para
-  UD-Q4_K_XL hasta ~136 GB para Q8_0); con menos RAM, Strata lee una parte desde el SSD mientras responde, lo que es
-  mucho más lento (7-8.5 tokens/s para UD-Q4_K_XL en un PC con 64 GB).
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs):** se instala a mano. No está en
-  el menú del instalador.
-
-Tamaños, descargas y qué cabe dónde: [docs/MODELS.md](docs/MODELS.md). Para añadir otro modelo más adelante, ejecuta
-`SETUP.bat` (Linux: `./setup.sh --setup`).
-
-## Cómo usarlo
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="La pestaña Monitor de la aplicación de Strata junto a un agente de programación"><br>
-<sub>El <b>Monitor</b> de la aplicación de Strata (izquierda) mientras un agente de programación escribe el jardín de la pagoda del vídeo (derecha)</sub></p>
-
- **En el navegador:** abre `http://127.0.0.1:8080`. Tiene **Chat**, un **Monitor** en vivo del modelo y de tu
-  GPU/CPU/RAM, y **About** con los ajustes y las direcciones.
- **Tus aplicaciones y agentes de programación:** añade un proveedor "compatible con OpenAI" con la URL base
-  **`http://127.0.0.1:8080/v1`**. Sirve cualquier clave de API y cualquier nombre de modelo.
-  - Aplicaciones que usan la API de Anthropic: `http://127.0.0.1:8080/v1/messages` (Claude Code:
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`).
-  - Codex CLI y otras aplicaciones que usan la API Responses de OpenAI: `/v1/responses`
-    ([configuración](docs/DETAILS.md#the-responses-api-and-codex-cli)).
- **Razonamiento:** elige **off, low, medium o high** en el menú del chat o en el "reasoning effort" de tu aplicación.
-  Off es lo más rápido. High es lo mejor para preguntas difíciles.
- **Imágenes:** responde que sí a "Images?" en la instalación. Luego haz clic en **Picture** en el chat, o adjunta
-  imágenes en tu aplicación. Las tarjetas AMD leen imágenes en Linux a través del procesador; en Windows todavía no.
- **Desde tu móvil u otro PC:** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`. Pon siempre una clave.
- **Una petición cada vez:** por defecto Strata responde una petición y las demás esperan. Para responder varias a la
-  vez, pon `"parallel": 2` ([BATCHING.md](docs/BATCHING.md)). En una tarjeta de 12 GB, cada respuesta va más lenta.
- **Prompts largos:** Strata lee entero el primer mensaje de un chat, más o menos 1 minuto por cada 30,000 tokens. Los
-  mensajes siguientes empiezan en segundos.
-
-Más: [dónde se guardan tus chats](docs/INSTALL.md#where-things-are-stored), [la API](docs/DETAILS.md#using-it).
-
-### Opcional: más velocidad con una sola tarjeta cuando todo el modelo cabe en la RAM
-
-Dos ajustes opcionales (de RubenTorney, #1904 y #1905). Ayudan si usas una tarjeta gráfica y tu RAM guarda todos los expertos (el modo arena de Strata, por ejemplo Q2_0 o IQ3_XXS en un PC con 64 GB). Abre tu configuración `strata-<model>.json` en la carpeta de datos de Strata ([dónde](docs/INSTALL.md#where-things-are-stored)) y añade:
-
- **Generación más rápida:** `"--adapt-async", "1"` en la lista `"args"`. La caché de expertos se actualiza entonces en un hilo auxiliar en vez de pausar la respuesta. Medido en una RTX 5070 (Windows, Q2_0): +4-5 % de generación, +7-10 % en código y documentos largos. Las respuestas pueden diferir un poco de las por defecto (son iguales de una ejecución a otra).
- **Lectura del prompt más rápida en Windows:** `"STRATA_PIN_BY_NEED": "1"` en el bloque `"env"`. Windows solo puede bloquear cerca de la mitad de la RAM para la tarjeta; esto bloquea primero los expertos que la tarjeta necesita de verdad. Medido en la RTX 5070: +4,4 % en la lectura del prompt.
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-Reinicia Strata (`START-HERE.bat` o `./setup.sh`) después del cambio. Para deshacerlo, quita las dos entradas.
+En Windows, abre una terminal nueva después. Luego:

-## ¿Algo salió mal?
+```sh
+strata launch
+```

- **Mi PC se congeló la primera vez que arrancó Strata.** Es normal mientras carga el modelo. Espera y no cierres la
-  ventana. ¿Sigue congelado después de 10 minutos? Reinicia el PC, cierra otros programas y vuelve a intentarlo, o
-  elige un tamaño más pequeño.
- **Se detuvo durante la descarga o la instalación.** Vuelve a ejecutar `START-HERE.bat` (o `./setup.sh`). Sigue
-  donde se detuvo.
- **Va muy lento y la luz del disco no deja de parpadear, o dice "the engine stopped unexpectedly".** Tu PC no tiene
-  suficiente RAM libre. Cierra otros programas (los navegadores usan mucha), o elige un tamaño más pequeño (Q2_0 o
-  IQ2_XS).
- **Dice que el puerto 8080 ya está en uso.** Strata ya está en marcha. Busca su ventana.
+Sigue las indicaciones para descargar e iniciar un modelo. [Guía del Terminal](docs/TERMINAL_LAUNCH.md).

-Más problemas y sus soluciones: [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md). ¿Sigues atascado? Abre un
-[issue](https://github.com/Niko1221/Strata/issues) y adjunta `strata-<model>.log` de la carpeta de Strata. ¿Has
-encontrado un problema de seguridad? Infórmalo en privado: [SECURITY.md](SECURITY.md).
+</details>

-## ¿Cómo funciona?
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Aplicación de Terminal de Strata con la actividad del modelo, la velocidad, la memoria y las peticiones recientes">
+  <br><sub>Observa tu modelo y tu hardware mientras se ejecuta.</sub>
+</p>

-Los modelos como este suelen funcionar en servidores con cientos de gigabytes de memoria gráfica. Tu tarjeta gráfica
-tiene 12-24 GB. Strata hace que el modelo quepa **repartiendo el trabajo por todo tu PC**. Piensa en una cocina: lo
-que usas todo el rato se queda en la encimera, y el resto espera en la despensa.
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="Los 24,576 expertos del modelo: los más usados en la tarjeta gráfica, todos en la RAM y una tabla de consulta en el SSD"></p>
+[Compilar desde el código fuente](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Guía de instalación completa](docs/INSTALL.md)

- **El modelo es un equipo de 24,576 pequeños especialistas ("expertos").** Cada palabra solo necesita 10 de ellos.
- **Tu tarjeta gráfica** guarda los pocos miles de expertos que más se usan. **Tu RAM** los tiene todos, y **tu
-  procesador** trabaja con el resto al mismo tiempo. **Tu SSD** guarda una gran tabla de consulta.
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="Un pequeño ayudante adivina las siguientes palabras; el modelo grande las comprueba todas a la vez y se queda con las correctas"></p>
+## Hardware

- **Adivinar y comprobar:** un pequeño ayudante adivina las siguientes palabras. El modelo grande las comprueba todas
-  a la vez. Recibes la misma respuesta, 1.6-1.8x antes.
- **Los textos largos se leen en trozos grandes** (hasta 8,192 tokens cada vez), a más de 1,000 tokens por segundo.
+| Hardware compatible | Guía |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50** | [Instalación en NVIDIA](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [Instalación en AMD](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · experimental** | [Instalación en RX 6000](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Instalación en Intel](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 o posterior** | [Instalación en Mac](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Instalación en Strix Halo](docs/STRIX_HALO.md) |

-La explicación larga: [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md). Cada parte y sus números:
-[los detalles](docs/DETAILS.md#how-it-works) y el [artículo](docs/paper/Strata-Paper.pdf).
+<a id="using-it"></a>

-## Créditos y licencia
+## Herramientas

-El modelo es [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next), del equipo de Qwen. Lo
-comprimieron [ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), UkisAI (Swift 1.5)
-y Unsloth. Strata usa partes de [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp). Todos los créditos:
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits). Strata es de código abierto con la [licencia MIT](LICENSE).
-Algunas partes y cada modelo tienen sus propias licencias ([cuáles](docs/HOW_IT_WORKS.md#license)).
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**, y más, mediante las API compatibles con OpenAI y Anthropic.

-## Apoya a Strata
+Ejecuta **`strata connect`** para ver las instrucciones de tu herramienta. [Guía de conexión](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).

-Strata es libre y de código abierto. Si te resulta útil, puedes apoyar su desarrollo:
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
+## Ayuda
+
+[Todas las guías](docs) · [Solución de problemas](docs/TROUBLESHOOTING.md) · [Informar de un error](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Benchmarks](docs/COMMUNITY_BENCHMARKS.md) · [Cómo funciona](docs/HOW_IT_WORKS.md) · [Contribuir](CONTRIBUTING.md)
+
+## Apoya Strata
+
+**Ayuda a mantener la IA local abierta a todos.** Un café ayuda a financiar el desarrollo y las pruebas en más hardware.
+
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: apoya Strata" height="48"></a>
+
+[Licencia MIT](LICENSE) · [Créditos y licencias de los modelos](docs/HOW_IT_WORKS.md#credits) · [Privacidad](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>Para herramientas de IA y lectores automáticos: <a href="AGENTS.md">referencia técnica</a> · <a href="docs/AI_SETUP.md">instrucciones de instalación</a>.</sub>
+
+**Patrocinios, alianzas de hardware o colaboraciones:** [[email protected]](mailto:[email protected]).
@@ -1,238 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [Deutsch](README.de.md) · **Français** · [Español](README.es.md) · [Português](README.pt-BR.md)
+<h3 align="center">Une IA puissante sur votre propre ordinateur.</h3>
+<p align="center">Discutez, programmez et travaillez avec des images, en local.</p>

-<p align="center"><b>Faites tourner un modèle d'IA de 125 milliards de paramètres sur votre propre PC de jeu</b><br>
-Carte graphique NVIDIA ou AMD (12 Go ou plus) · Windows ou Linux · gratuit et open source</p>
+<p align="center">
+  <a href="#modèles">Modèles</a> · <a href="#installation"><b>Installation</b></a> ·
+  <a href="#matériel">Matériel</a> · <a href="#outils">Outils</a> ·
+  <a href="#aide">Aide</a> · <a href="#soutenir-strata">Soutenir</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Un jardin de pagode en voxels écrit par le modèle de Strata, qui tourne dans le navigateur"></a><br>
-<sub>Un jardin de pagode en voxels, généré en une seule requête sur une RTX 5070 avec Strata (IQ3_S, contexte de 128K) ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">vidéo complète (49 s)</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Télécharger Strata"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="Licence MIT"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Soutenir Strata sur Buy Me a Coffee"></a>
+</p>

-Strata fait tourner **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** sur un PC normal. C'est
-un grand modèle d'IA, très capable, qui demande d'habitude un serveur. Il discute, écrit du code, lit des images et
-fonctionne avec vos applications et vos agents de code. Rien ne quitte votre PC.
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <b>Français</b> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## Quelle est sa vitesse ?
+**Gratuit, open source, et à vous de l'exécuter.** Utilisez Strata sur votre bureau ou avec vos outils de programmation préférés. Aucun compte nécessaire.

-Nous l'avons mesurée sur deux PC de jeu ordinaires. Un token correspond à environ ¾ d'un mot.
+## Modèles

- **Écrit les réponses :** la vitesse à laquelle la réponse s'affiche dans une courte discussion. 60 tokens par seconde, c'est plus rapide que votre lecture.
- **Lit votre prompt :** la vitesse à laquelle il absorbe ce que vous envoyez (ici un document, du code ou un historique de discussion de 32K tokens).
+Nous recommandons **d'abord ISTA-DASLab**, puis **Unsloth** et d'autres fournisseurs, lorsqu'un modèle compatible tient en mémoire.

-<table>
-<tr><th>NVIDIA : RTX 5070 (12 Go), Ryzen 5 7600, 64 Go de RAM</th><th>AMD : RX 9070 XT (16 Go), Ryzen 9 3900X, 47 Go de RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| Taille | Écrit les réponses | Lit votre prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| Taille | Écrit les réponses | Lit votre prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA : Q2_0 avec le moteur 0.1.36, les autres lignes avec 0.1.26 (réponses de 4K, prompts de 32K). Les tableaux
-complets sont dans [DETAILS.md](docs/DETAILS.md#speed-measured). Une carte avec plus de VRAM va plus vite : une
-RTX 3090 (24 Go) devrait écrire environ 100-140 tokens par seconde. Longues discussions et autres cartes :
-[vitesse de chaque modèle](docs/MODELS.md#how-fast-is-each-size), [résultats de la communauté](docs/COMMUNITY_BENCHMARKS.md).
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>Strata est gratuit. S'il tourne bien sur votre PC, un café aide à poursuivre le travail.</sub></p>
-
-## Ce qu'il vous faut
-
-| | |
+| Fournisseur | Choix |
 | --- | --- |
-| **Carte graphique** | **NVIDIA** GeForce RTX série 20, 30, 40 ou 50, ou **AMD** Radeon RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT, Radeon AI PRO R9700 ou série RX 6800 / 6900. Il faut **12 Go de VRAM ou plus**. |
-| **RAM** | 32 Go ou plus. Votre RAM décide [quel modèle](#quel-modèle-choisir-) tient. Avec 64 Go, toutes les tailles tournent. |
-| **Disque** | Environ 80 Go libres. Prenez un SSD si possible : le premier démarrage est bien plus rapide. |
-| **Système** | Windows 10 / 11 ou Linux, avec un pilote graphique NVIDIA ou AMD à jour. |
+| **ISTA-DASLab · recommandé** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder : IQ1\_M](docs/MODELS.md#coder) pour programmer. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Utilise moins de mémoire, mais plus lent. |
+| **Autres options** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-L'installateur s'occupe de tout le reste. Deux ou trois cartes peuvent se partager le modèle ([multi-GPU](docs/MULTI_GPU.md)).
+[Comparer les tailles, la mémoire nécessaire et la compatibilité](docs/MODELS.md).

-Expérimental, écrit et testé par des membres de la communauté sur leurs propres machines :
+</details>

- **Cartes graphiques plus anciennes** (Tesla P40 / V100, GTX 10, Radeon VII / MI50, RX 6700 XT, RX 5500 XT) : [Older GPUs](docs/OLDER_GPUS.md).
- **Intel Arc**, compilé depuis les sources sous Linux : [Intel Arc](docs/INTEL_ARC.md).
- **AMD Ryzen AI Max (Strix Halo)**, compilé depuis les sources sous Linux : [Strix Halo](docs/STRIX_HALO.md).
- **Processeurs plus anciens sans AVX2** : ça marche, mais lentement. [Older CPUs](docs/INSTALL.md#older-cpus-experimental).
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-La liste complète : [docs/INSTALL.md](docs/INSTALL.md#what-you-need).
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. Ce sont les paquets actuellement documentés pour ce modèle.
+
+[Guide du modèle et compatibilité](docs/QWEN36.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+Dans l'**application de bureau** et dans le **Terminal**. Ce qui ne tient pas en mémoire est lu depuis votre SSD : il faut donc beaucoup d'espace disque libre.
+
+| Jeu (IST-DAS) | Téléchargement | Espace disque libre nécessaire |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | environ 245 GB |
+| 2.00 bpw | 257 GB | environ 265 GB |
+| 2.25 bpw | 274 GB | environ 280 GB |
+
+Fonctionne sur les NVIDIA RTX 30, 40 et 50 (Windows et Linux) et sur l'AMD Radeon AI PRO R9700 (Linux). L'installation télécharge les fichiers et le moteur DeepSeek, puis démarre le modèle.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Mesuré avec le jeu 2.00 bpw sur Strata 0.2.5. « Sortie » est la vitesse de la réponse, « Prompt » la vitesse à laquelle Strata lit votre texte.
+
+| Matériel | Sortie | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB de RAM | 4 à 6 tokens/s | environ 110 tokens/s (4K) |
+| RTX 3060 12 GB, 46 GB de RAM | 9 à 11 tokens/s | environ 155 tokens/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB de RAM | 21 à 25 tokens/s | 320 à 360 tokens/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 à 77 tokens/s | 400 à 450 tokens/s (8K) |
+
+[Mémoire, disque et détails](docs/DEEPSEEK41.md) · [Notes de version](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+Vous ne savez pas ce qui tient ? [Choisir un modèle pour votre ordinateur](docs/MODELS.md#pick-by-memory).

 ## Installation

-### Laissez votre IA l'installer
+<a id="option-a-the-strata-app"></a>

-Vous utilisez un assistant de code IA (Claude Code, Cursor, Codex, GitHub Copilot, ...) ? Collez-lui ceci :
+### Application de bureau

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[Télécharger Strata pour Windows, Linux ou Mac →](https://github.com/Niko1221/Strata/releases/latest)**
+
+Installez l'application, choisissez un modèle et commencez à discuter. Il y a un seul installateur par système. Au premier lancement, l'application télécharge le moteur de votre carte graphique. [Aide pour l'installateur](docs/INSTALL.md#the-app).
+
+<sub>Fichiers: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Application de bureau Strata avec une discussion et un aperçu du code en direct côte à côte">
+  <br><sub>Discussion, fichiers et aperçu en direct dans une seule fenêtre.</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### Application Terminal
+
+Vous préférez le terminal ? Installez Strata, puis lancez **`strata launch`**.
+
+<details open>
+<summary><b>Commandes d'installation</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-Il vérifie votre carte graphique, votre RAM et votre disque, et choisit le modèle qui convient. Ensuite il l'installe,
-le démarre et vous explique comment connecter vos applications. Les outils d'IA peuvent aussi installer, démarrer et
-arrêter Strata grâce à son [serveur MCP](docs/MCP_SERVER.md).
+**Windows PowerShell**

-### Ou faites-le vous-même
-
-[Téléchargez Strata](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) et décompressez-le (ou faites un `git clone`).
-**Windows :** double-cliquez sur **`START-HERE.bat`**. **Linux :** lancez **`./setup.sh`** dans le dossier Strata.
-
-**Mac (Apple Silicon, M1 à M5, macOS 15 ou plus récent) :** installez une fois les Command Line Tools d'Apple (`xcode-select --install` dans le Terminal ; Xcode lui-même n'est pas nécessaire). Ouvrez ensuite le Terminal dans le dossier Strata et lancez **`./setup.sh`**. Il compile le moteur Mac sur votre Mac (environ 7 minutes), pose les mêmes questions, télécharge le modèle et le démarre. La fois suivante, `./setup.sh` démarre tout de suite. Quelle taille convient à votre Mac et sa vitesse : [docs/MAC.md](docs/MAC.md).
-
-Les étapes sont les mêmes pour NVIDIA et AMD. L'installateur détecte votre carte et installe le bon moteur pour elle.
-Il vous pose quelques questions :
-
- quel modèle et quelle taille,
- combien de contexte (la quantité de texte que le modèle garde en tête),
- s'il doit lire les images.
-
-Appuyez sur Entrée à chaque fois pour garder la réponse recommandée. Ensuite il télécharge le modèle (environ 70 Go)
-et le démarre. Si le téléchargement s'arrête, relancez-le : il reprend là où il s'était arrêté. Votre navigateur
-ouvre l'application Strata à l'adresse `http://127.0.0.1:8080`.
-
-> **Pendant le démarrage du modèle, votre PC peut ralentir ou ne plus répondre pendant 1-3 minutes** (plus longtemps la première fois).
-> Strata charge 35-55 Go dans votre RAM et en réserve une partie pour la carte graphique. C'est normal. Attendez, et
-> ne fermez pas la fenêtre. La fenêtre montre ce que fait Strata.
-
-**La fois suivante**, relancez `START-HERE.bat` (ou `./setup.sh`). Il démarre tout de suite et ne télécharge rien
-deux fois. Fermez sa fenêtre pour arrêter le modèle. `UPDATE.bat` (`./update.sh`) met Strata à jour sans le démarrer.
-Mises à jour, Docker, plusieurs cartes, emplacement des fichiers et toutes les options : [docs/INSTALL.md](docs/INSTALL.md).
-
-## Quel modèle choisir ?
-
-L'installateur en recommande un selon votre RAM. Le même modèle existe en plusieurs tailles, plus ou moins
-compressées. Les petites tailles sont plus rapides. Les grandes sont un peu plus intelligentes.
-
-| Votre RAM | Prenez | Pourquoi |
-| --- | --- | --- |
-| **32 Go** | **Coder** | il tient dans 32 Go et il est fait pour le code (avec une carte de 24 Go, Q2_0 et IQ2_XS tournent aussi) |
-| **48 Go** | **IQ2_XS** (ou Q2_0, le plus rapide) | les plus grandes tailles ne tiennent pas |
-| **64 Go** | **IQ2_XS** (recommandé), ou IQ3_XXS / IQ3_S | toutes les tailles tiennent ; IQ3_S est le meilleur et le plus lent |
-| **96 Go ou plus** | **IQ3_S**, ou l'UD-IQ4_XS d'Unsloth (~4 bits) | de la place pour les plus grandes tailles, avec tout le reste ouvert |
-
- **[Coder](docs/MODELS.md#coder) :** une version pour le code, avec la moitié des experts en moins. Elle atteint 91 %
-  du score SWE-bench Verified du modèle complet (mesuré par ses auteurs) et tient dans 32 Go de RAM. Elle est moins
-  bonne en dehors du code, y compris pour le chinois et les autres textes CJK (#438). Pour ces cas, prenez Q2_0,
-  IQ2_XS ou IQ3_S, qui gardent tous les experts.
- **[Swift 1.5](docs/MODELS.md#swift-15) :** un fine-tune qui réfléchit bien moins longtemps avant de répondre. Vous
-  avez la réponse plus tôt, avec à peu près la même qualité.
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs)** : la version ~4 bits d'Unsloth, entre IQ3_S et
-  UD-Q4_K_XL en qualité. Un téléchargement de 94 Go. Avec moins de ~80 Go de RAM, Strata en lit une partie depuis
-  le SSD pendant qu'il répond, il y est donc plus lent (un SSD NVMe aide).
- **[Unsloth UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL et Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0) :** de 4 à 8 bits, plus proches du modèle
-  complet (93-95 % le même token suivant que Q8_0). Rapides quand tous les experts tiennent dans la RAM (~88 Go pour
-  UD-Q4_K_XL jusqu'à ~136 Go pour Q8_0) ; avec moins de RAM, Strata en lit une partie depuis le SSD pendant qu'il
-  répond, ce qui est bien plus lent (7-8.5 tokens/s pour UD-Q4_K_XL sur un PC avec 64 Go).
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs) :** vous l'installez à la main.
-  Il n'est pas dans le menu de l'installateur.
-
-Tailles, téléchargements et ce qui tient où : [docs/MODELS.md](docs/MODELS.md). Pour ajouter un autre modèle plus
-tard, lancez `SETUP.bat` (Linux : `./setup.sh --setup`).
-
-## Utilisation
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="L'onglet Monitor de l'application Strata à côté d'un agent de code"><br>
-<sub>Le <b>Monitor</b> de l'application Strata (à gauche) pendant qu'un agent de code écrit le jardin de pagode de la vidéo (à droite)</sub></p>
-
- **Dans le navigateur :** ouvrez `http://127.0.0.1:8080`. Vous y trouvez **Chat**, un **Monitor** en direct du
-  modèle et de votre GPU/CPU/RAM, et **About** avec les réglages et les adresses.
- **Vos applications et agents de code :** ajoutez un fournisseur « OpenAI-compatible » avec l'URL de base
-  **`http://127.0.0.1:8080/v1`**. N'importe quelle clé API et n'importe quel nom de modèle fonctionnent.
-  - Applications qui utilisent l'API d'Anthropic : `http://127.0.0.1:8080/v1/messages` (Claude Code :
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`).
-  - Codex CLI et les autres applications qui utilisent l'API OpenAI Responses : `/v1/responses`
-    ([configuration](docs/DETAILS.md#the-responses-api-and-codex-cli)).
- **Réflexion :** choisissez **off, low, medium ou high** dans le menu du chat ou dans le « reasoning effort » de
-  votre application. Off est le plus rapide. High est le meilleur pour les questions difficiles.
- **Images :** répondez oui à « Images? » pendant l'installation. Ensuite cliquez sur **Picture** dans le chat, ou
-  joignez des images dans votre application. Les cartes AMD lisent les images sous Linux via le processeur ; sous
-  Windows, pas encore.
- **Depuis votre téléphone ou un autre PC :** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`. Définissez
-  toujours une clé.
- **Une requête à la fois :** par défaut, Strata répond à une requête et les autres attendent. Pour répondre à
-  plusieurs en même temps, mettez `"parallel": 2` ([BATCHING.md](docs/BATCHING.md)). Sur une carte de 12 Go, chaque
-  réponse devient alors plus lente.
- **Longs prompts :** Strata lit en entier le premier message d'une discussion, environ 1 minute pour 30,000 tokens.
-  Les messages suivants démarrent en quelques secondes.
-
-Plus d'infos : [où sont stockées vos discussions](docs/INSTALL.md#where-things-are-stored), [l'API](docs/DETAILS.md#using-it).
-
-### Optionnel : plus de vitesse sur une seule carte quand tout le modèle tient en RAM
-
-Deux réglages optionnels (de RubenTorney, #1904 et #1905). Ils aident si vous utilisez une seule carte graphique et que votre RAM contient tous les experts (le mode arena de Strata, par exemple Q2_0 ou IQ3_XXS sur un PC de 64 Go). Ouvrez votre configuration `strata-<model>.json` dans le dossier de données de Strata ([où](docs/INSTALL.md#where-things-are-stored)) et ajoutez :
-
- **Génération plus rapide :** `"--adapt-async", "1"` dans la liste `"args"`. Le cache d'experts est alors mis à jour dans un thread auxiliaire au lieu de mettre la réponse en pause. Mesuré sur une RTX 5070 (Windows, Q2_0) : +4-5 % de génération, +7-10 % sur le code et les longs documents. Les réponses peuvent légèrement différer de celles par défaut (elles restent identiques d'une exécution à l'autre).
- **Lecture du prompt plus rapide sous Windows :** `"STRATA_PIN_BY_NEED": "1"` dans le bloc `"env"`. Windows ne peut verrouiller qu'environ la moitié de la RAM pour la carte ; ce réglage verrouille d'abord les experts dont la carte a vraiment besoin. Mesuré sur la RTX 5070 : +4,4 % en lecture du prompt.
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-Redémarrez Strata (`START-HERE.bat` ou `./setup.sh`) après la modification. Pour annuler, retirez les deux entrées.
+Sous Windows, ouvrez ensuite un nouveau terminal. Puis :

-## Un problème ?
+```sh
+strata launch
+```

- **Mon PC s'est figé au premier démarrage de Strata.** C'est normal pendant le chargement du modèle. Attendez, et ne
-  fermez pas la fenêtre. Toujours figé après 10 minutes ? Redémarrez le PC, fermez les autres programmes et
-  réessayez, ou choisissez une taille plus petite.
- **Il s'est arrêté pendant le téléchargement ou l'installation.** Relancez `START-HERE.bat` (ou `./setup.sh`). Il
-  reprend là où il s'était arrêté.
- **C'est très lent et le voyant du disque clignote sans arrêt, ou il affiche « the engine stopped unexpectedly ».**
-  Votre PC n'a pas assez de RAM libre. Fermez les autres programmes (les navigateurs en utilisent beaucoup), ou
-  choisissez une taille plus petite (Q2_0 ou IQ2_XS).
- **Il dit que le port 8080 est déjà utilisé.** Strata tourne déjà. Cherchez sa fenêtre.
+Suivez les invites pour télécharger et démarrer un modèle. [Guide du Terminal](docs/TERMINAL_LAUNCH.md).

-Autres problèmes et leurs solutions : [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md). Toujours bloqué ? Ouvrez une
-[issue](https://github.com/Niko1221/Strata/issues) et joignez `strata-<model>.log` depuis le dossier Strata. Vous
-avez trouvé un problème de sécurité ? Signalez-le en privé : [SECURITY.md](SECURITY.md).
+</details>

-## Comment ça marche ?
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Application Terminal de Strata affichant l'activité du modèle, la vitesse, la mémoire et les requêtes récentes">
+  <br><sub>Suivez votre modèle et votre matériel pendant qu'il tourne.</sub>
+</p>

-Les modèles comme celui-ci tournent d'habitude sur des serveurs avec des centaines de gigaoctets de mémoire
-graphique. Votre carte graphique a 12-24 Go. Strata fait tenir le modèle en **répartissant le travail sur tout votre
-PC**. Pensez à une cuisine : ce que vous utilisez tout le temps reste sur le plan de travail, et le reste attend dans
-le placard.
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="Les 24,576 experts du modèle : les plus sollicités sur la carte graphique, tous en RAM, une table de correspondance sur le SSD"></p>
+[Compiler depuis les sources](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Guide d'installation complet](docs/INSTALL.md)

- **Le modèle est une équipe de 24,576 petits spécialistes (les « experts »).** Chaque mot n'en demande que 10.
- **Votre carte graphique** garde les quelques milliers d'experts les plus utilisés. **Votre RAM** les contient tous,
-  et **votre processeur** travaille sur les autres en même temps. **Votre SSD** contient une grande table de
-  correspondance.
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="Un petit assistant devine les mots suivants ; le grand modèle les vérifie tous d'un coup et garde les bons"></p>
+## Matériel

- **Deviner, puis vérifier :** un petit assistant devine les quelques mots suivants. Le grand modèle les vérifie
-  tous d'un coup. Vous obtenez la même réponse, 1.6-1.8x plus tôt.
- **Les longs textes sont lus par gros morceaux** (jusqu'à 8,192 tokens à la fois), à plus de 1,000 tokens par seconde.
+| Matériel pris en charge | Guide |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50** | [Installation NVIDIA](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [Installation AMD](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · expérimental** | [Installation RX 6000](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Installation Intel](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 ou plus récent** | [Installation sur Mac](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Installation Strix Halo](docs/STRIX_HALO.md) |

-L'explication plus longue : [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md). Chaque partie et ses chiffres :
-[les détails](docs/DETAILS.md#how-it-works) et l'[article](docs/paper/Strata-Paper.pdf).
+<a id="using-it"></a>

-## Crédits et licence
+## Outils

-Le modèle est [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next), de l'équipe Qwen. Il a été
-compressé par [ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), UkisAI (Swift 1.5)
-et Unsloth. Strata utilise des parties de [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp). Tous les
-crédits : [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits). Strata est open source sous [licence MIT](LICENSE).
-Quelques parties et chaque modèle ont leur propre licence ([lesquelles](docs/HOW_IT_WORKS.md#license)).
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**, et d'autres via les API compatibles OpenAI et Anthropic.
+
+Lancez **`strata connect`** pour voir la configuration de votre outil. [Guide de connexion](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## Aide
+
+[Tous les guides](docs) · [Dépannage](docs/TROUBLESHOOTING.md) · [Signaler un bogue](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Benchmarks](docs/COMMUNITY_BENCHMARKS.md) · [Comment ça marche](docs/HOW_IT_WORKS.md) · [Contribuer](CONTRIBUTING.md)

 ## Soutenir Strata

-Strata est gratuit et open source. S'il vous est utile, vous pouvez soutenir son développement :
+**Aidez à garder l'IA locale ouverte à tous.** Un café aide à financer le développement et les tests sur davantage de matériel.

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee : soutenir Strata" height="48"></a>
+
+[Licence MIT](LICENSE) · [Crédits et licences des modèles](docs/HOW_IT_WORKS.md#credits) · [Confidentialité](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>Pour les outils d'IA et les lecteurs automatiques : <a href="AGENTS.md">référence technique</a> · <a href="docs/AI_SETUP.md">instructions d'installation</a>.</sub>
+
+**Parrainages, partenariats matériel ou collaborations :** [[email protected]](mailto:[email protected]).
@@ -1,229 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · [简体中文](README.zh-CN.md) · **日本語** · [Deutsch](README.de.md) · [Français](README.fr.md) · [Español](README.es.md) · [Português](README.pt-BR.md)
+<h3 align="center">あなた自身のパソコンで、高性能な AI を。</h3>
+<p align="center">チャット、コーディング、画像の処理を、すべてローカルで。</p>

-<p align="center"><b>1,250 億パラメータの AI モデルを、手元のゲーミング PC で動かす</b><br>
-NVIDIA または AMD のグラフィックカード（12 GB 以上） · Windows または Linux · 無料・オープンソース</p>
+<p align="center">
+  <a href="#モデル">モデル</a> · <a href="#インストール"><b>インストール</b></a> ·
+  <a href="#ハードウェア">ハードウェア</a> · <a href="#ツール">ツール</a> ·
+  <a href="#ヘルプ">ヘルプ</a> · <a href="#strata-を支援する">支援</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Strata で生成した、五重塔のある庭。ボクセルで表現され、ブラウザーで動作している"></a><br>
-<sub>五重塔のある庭をボクセルで表現。RTX 5070 で動かした Strata（IQ3_S、コンテキスト長 128K）に、1 回のプロンプトで作成を依頼 ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">動画を見る（全編 49 秒）</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Strata をダウンロード"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="MIT ライセンス"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Buy Me a Coffee で Strata を支援する"></a>
+</p>

-Strata を使うと、**[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** を一般的な PC で動かせます。
-通常はサーバーを必要とする大規模で高性能な AI モデルで、チャットやコードの生成、画像の読み取りができます。
-アプリやコーディングエージェントとも連携でき、データは PC の外に送信されません。
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <b>日本語</b> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## どのくらい速い？
+**無料でオープンソース。自分の環境で動かせます。** デスクトップで、またはお好みのコーディングツールと一緒に Strata を使えます。アカウントは不要です。

-一般的なゲーミング PC 2 台で速度を測定しました。英語の場合、1 トークンはおよそ ¾ 語に相当します。
+## モデル

- **生成速度：** 短いチャットで回答を生成する速度です。毎秒 60 トークンなら、人が読むよりも速く文章が表示されます。
- **プロンプトの読み込み：** 入力した内容を読み込む速度です。ここでは、文書やコード、チャット履歴など 32K トークン分を読み込ませています。
+まず **ISTA-DASLab** をおすすめします。次に **Unsloth** などの提供元です。メモリに収まる互換モデルがある場合に選べます。

-<table>
-<tr><th>NVIDIA: RTX 5070 (12 GB), Ryzen 5 7600, 64 GB RAM</th><th>AMD: RX 9070 XT (16 GB), Ryzen 9 3900X, 47 GB RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| モデルサイズ | 生成速度 | プロンプトの読み込み |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| モデルサイズ | 生成速度 | プロンプトの読み込み |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA の測定には、Q2_0 のみエンジン 0.1.36、それ以外は 0.1.26 を使用しています（回答 4K、プロンプト 32K）。測定結果の詳細は
-[DETAILS.md](docs/DETAILS.md#speed-measured) をご覧ください。VRAM の容量が大きいカードほど高速で、RTX 3090（24 GB）なら
-毎秒およそ 100-140 トークンの生成速度が見込めます。長いチャットや他のカードでの性能については、[モデルごとの速度](docs/MODELS.md#how-fast-is-each-size)や
-[コミュニティの測定結果](docs/COMMUNITY_BENCHMARKS.md)を参照してください。
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>Strata は無料で使えます。お使いの PC で快適に動いたら、コーヒー 1 杯分のご支援が開発を続ける励みになります。</sub></p>
-
-## 必要なもの
-
-| | |
+| 提供元 | 選択肢 |
 | --- | --- |
-| **グラフィックカード** | **NVIDIA** GeForce RTX 20、30、40、50 シリーズ、または **AMD** Radeon RX 7900 XT / XTX、RX 7800 XT / 7700 XT、RX 9060 XT、RX 9070 / 9070 XT、Radeon AI PRO R9700、RX 6800 / 6900 シリーズ。**VRAM 12 GB 以上**が必要です。 |
-| **RAM** | 32 GB 以上。[利用できるモデル](#どのモデルを選べばいい)は RAM の容量によって異なります。64 GB あれば、どのサイズも利用できます。 |
-| **ディスク** | 約 80 GB の空き容量。SSD を使うと初回の起動が大幅に速くなるため、おすすめです。 |
-| **OS** | Windows 10 / 11 または Linux。NVIDIA または AMD の最新のグラフィックドライバーも必要です。 |
+| **ISTA-DASLab · おすすめ** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S。[Coder: IQ1\_M](docs/MODELS.md#coder)（コーディング向け）。 |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF)。メモリ使用量は少ないですが、動作は遅くなります。 |
+| **その他の選択肢** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-その他の必要なソフトウェアは、インストーラーが用意します。2 枚または 3 枚のカードにモデルを分散させることもできます（[マルチ GPU](docs/MULTI_GPU.md)）。
+[サイズ、必要なメモリ、互換性を比べる](docs/MODELS.md)。

-以下のハードウェアにも試験的に対応しています。いずれもコミュニティのメンバーが手元のマシンで実装・テストしたものです。
+</details>

- **旧世代のグラフィックカード**（Tesla P40 / V100、GTX 10、Radeon VII / MI50、RX 6700 XT、RX 5500 XT）：[旧世代 GPU の対応状況](docs/OLDER_GPUS.md)。
- **Intel Arc**（Linux でソースからビルド）：[Intel Arc の対応状況](docs/INTEL_ARC.md)。
- **AMD Ryzen AI Max（Strix Halo）**（Linux でソースからビルド）：[Strix Halo の対応状況](docs/STRIX_HALO.md)。
- **AVX2 非対応の旧世代 CPU**：動作しますが、速度は遅くなります。[旧世代 CPU の対応状況](docs/INSTALL.md#older-cpus-experimental)を参照してください。
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-必要な環境の一覧は、[docs/INSTALL.md](docs/INSTALL.md#what-you-need)をご覧ください。
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0。現在、このモデルで文書化されているパックです。
+
+[モデルガイドと互換性](docs/QWEN36.md)。
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+**デスクトップアプリ**と**ターミナル**で使えます。メモリに収まらない分は SSD から読み込むため、空きディスク容量がたくさん必要です。
+
+| セット（IST-DAS） | ダウンロード | 必要な空き容量 |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | 約245 GB |
+| 2.00 bpw | 257 GB | 約265 GB |
+| 2.25 bpw | 274 GB | 約280 GB |
+
+NVIDIA RTX 30・40・50 シリーズ（Windows と Linux）と、AMD Radeon AI PRO R9700（Linux）で動きます。セットアップがファイルと DeepSeek エンジンをダウンロードし、モデルを起動します。
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Strata 0.2.5 で 2.00 bpw のセットを使って測定しました。「出力」は回答の速さ、「プロンプト」は Strata が入力を読み込む速さです。
+
+| ハードウェア | 出力 | プロンプト |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB RAM | 4〜6 トークン/秒 | 約 110 トークン/秒 (4K) |
+| RTX 3060 12 GB, 46 GB RAM | 9〜11 トークン/秒 | 約 155 トークン/秒 (4K) |
+| 1x Radeon AI PRO R9700, 251 GB RAM | 21〜25 トークン/秒 | 320〜360 トークン/秒 (8K) |
+| 4x Radeon AI PRO R9700 | 74〜77 トークン/秒 | 400〜450 トークン/秒 (8K) |
+
+[メモリ、ディスク、詳細](docs/DEEPSEEK41.md) · [リリースノート](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+どれが動くかわからない場合は、[お使いのパソコンに合うモデルを選ぶ](docs/MODELS.md#pick-by-memory)。

 ## インストール

-### AI にセットアップしてもらう
+<a id="option-a-the-strata-app"></a>

-Claude Code、Cursor、Codex、GitHub Copilot などの AI コーディングアシスタントを使っている場合は、次の文を貼り付けてください。
+### デスクトップアプリ

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[Windows、Linux、Mac 用の Strata をダウンロード →](https://github.com/Niko1221/Strata/releases/latest)**
+
+アプリをインストールし、モデルを選んで、チャットを始めましょう。インストーラーはシステムごとに1つです。初回起動時に、アプリがお使いのグラフィックスカード用のエンジンをダウンロードします。[インストーラーのヘルプ](docs/INSTALL.md#the-app)。
+
+<sub>ファイル: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="チャットとライブのコードプレビューを並べて表示した Strata デスクトップアプリ">
+  <br><sub>チャット、ファイル、ライブプレビューを1つのウィンドウで。</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### ターミナルアプリ
+
+ターミナルのほうが好みですか？ Strata をインストールして、**`strata launch`** を実行します。
+
+<details open>
+<summary><b>インストールコマンド</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-AI がグラフィックカード、RAM、ディスクを確認して、PC に合ったモデルを選びます。インストールと起動を行い、
-アプリとの接続方法も案内します。また、Strata の [MCP サーバー](docs/MCP_SERVER.md) を使えば、
-AI ツールから Strata のインストール・起動・停止を行えます。
+**Windows PowerShell**

-### 自分でやる
-
-[Strata をダウンロード](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip)して展開します（`git clone` でも構いません）。
-**Windows：** **`START-HERE.bat`** をダブルクリックします。**Linux：** Strata フォルダーで **`./setup.sh`** を実行します。
-
-**Mac（Apple シリコン、M1〜M5、macOS 15 以降）：** まず一度だけ Apple の Command Line Tools をインストールします（ターミナルで `xcode-select --install`。Xcode 本体は不要です）。次に Strata フォルダーでターミナルを開き、**`./setup.sh`** を実行します。Mac 用エンジンをお使いの Mac 上でビルドし（約 7 分）、同じ質問をしてからモデルをダウンロードして起動します。次回からは `./setup.sh` ですぐに起動します。どのサイズが Mac に合うかと速度：[docs/MAC.md](docs/MAC.md)。
-
-NVIDIA でも AMD でも手順は同じです。インストーラーがカードを検出し、対応するエンジンを用意します。
-続いて、次の項目を設定します。
-
- 使用するモデルとサイズ
- コンテキストの長さ（モデルが覚えておけるテキストの量）
- 画像を読み取る機能を使うかどうか
-
-各項目で Enter を押すと、推奨設定が選ばれます。設定が終わるとモデル（約 70 GB）をダウンロードし、起動します。
-ダウンロードが途中で止まった場合は、もう一度実行すると続きから再開できます。起動が完了すると、ブラウザーで
-`http://127.0.0.1:8080` が開き、Strata の画面が表示されます。
-
-> **モデルの起動中は、1-3 分ほど PC の動作が遅くなったり、応答しなくなったりすることがあります**（初回は特に時間がかかります）。
-> Strata が 35-55 GB のデータを RAM に読み込み、その一部をグラフィックカード用に固定（ピン留め）しているためです。
-> 正常な動作なので、ウィンドウに表示される処理状況を確認しながら、閉じずにお待ちください。
-
-**次回からは** `START-HERE.bat`（または `./setup.sh`）を実行するだけですぐに起動できます。2 回目以降は、ダウンロード済みのファイルを再度取得する必要はありません。
-モデルを停止するにはウィンドウを閉じてください。`UPDATE.bat`（`./update.sh`）を使うと、Strata を起動せずに更新できます。
-更新方法や Docker、複数のカードの使い方、ファイルの保存先、各種オプションについては、[docs/INSTALL.md](docs/INSTALL.md)をご覧ください。
-
-## どのモデルを選べばいい
-
-インストーラーが RAM の容量に合ったモデルをおすすめします。同じモデルでも、圧縮率によって複数のサイズが用意されています。
-サイズが小さいほど高速に動作し、大きいほど回答の品質が少し高くなります。
-
-| RAM | おすすめのモデル | 選ぶ理由 |
-| --- | --- | --- |
-| **32 GB** | **Coder** | 32 GB で動作するコーディング向けモデル（24 GB のカードがあれば Q2_0 と IQ2_XS も動作） |
-| **48 GB** | **IQ2_XS**（速度優先なら Q2_0） | これより大きいサイズはメモリに収まらない |
-| **64 GB** | **IQ2_XS**（おすすめ）、または IQ3_XXS / IQ3_S | どのサイズも利用可能。IQ3_S は回答の品質が最も高い一方、速度は最も遅い |
-| **96 GB 以上** | **IQ3_S**、または Unsloth の UD-IQ4_XS（約 4-bit） | 他のアプリを開いたままでも、最大サイズのモデルを動かせるだけの余裕がある |
-
- **[Coder](docs/MODELS.md#coder)：** エキスパートを半分に減らしたコーディング向けモデルです。SWE-bench Verified ではフルモデルのスコアの
-  91% を達成しており（開発者による測定）、32 GB の RAM で動作します。ただし、コード以外の用途では性能が劣り、中国語などの CJK 言語の処理も苦手です（#438）。
-  こうした用途には、すべてのエキスパートを残した Q2_0、IQ2_XS、IQ3_S を選んでください。
- **[Swift 1.5](docs/MODELS.md#swift-15)：** 回答前の思考時間が大幅に短くなるようファインチューニングしたモデルです。
-  回答の品質をほぼ保ったまま、より短い時間で答えが返ってきます。
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs)：** Unsloth による約 4-bit のモデルです。回答の品質は IQ3_S と UD-Q4_K_XL の中間です。
-  ダウンロード容量は 94 GB です。RAM が約 80 GB 未満の場合、回答の生成中にモデルの一部を SSD から読み込むため、速度が落ちます（NVMe SSD を使うと改善します）。
- **[Unsloth UD-Q4_K_XL / UD-Q5_K_XL / UD-Q6_K_XL / Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0)：** 4〜8 ビットで、フルモデルにより近いモデルです
-  （次のトークンが Q8_0 と一致する割合は 93〜95%）。すべてのエキスパートが RAM に収まる場合（UD-Q4_K_XL で約 88 GB、
-  Q8_0 で約 136 GB）は高速です。RAM が足りない場合は回答の生成中に一部を SSD から読み込むため、大幅に遅くなります
-  （RAM が 64 GB の PC で UD-Q4_K_XL は毎秒 7-8.5 トークン程度）。
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs)：** 手動でのセットアップが必要です。
-  インストーラーのメニューからは選べません。
-
-各サイズのダウンロード情報や必要なメモリ容量は、[docs/MODELS.md](docs/MODELS.md)をご覧ください。後から別のモデルを追加する場合は、
-`SETUP.bat`（Linux：`./setup.sh --setup`）を実行してください。
-
-## 使い方
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="Strata の Monitor タブ（左）と、コードを生成するコーディングエージェント（右）"><br>
-<sub>動画に登場する五重塔の庭を作成中の画面。左が Strata の <b>Monitor</b>、右がコードを生成しているコーディングエージェント</sub></p>
-
- **ブラウザーで使う：** `http://127.0.0.1:8080` を開きます。チャット用の **Chat**、モデルや GPU/CPU/RAM の状態をリアルタイムで確認できる **Monitor**、
-  設定や接続先のアドレスを確認できる **About** の各タブがあります。
- **アプリやコーディングエージェントと連携する：** 「OpenAI-compatible」プロバイダーを追加し、ベース URL に
-  **`http://127.0.0.1:8080/v1`** を指定します。API キーとモデル名には任意の値を指定できます。
-  - Anthropic API を使うアプリ：`http://127.0.0.1:8080/v1/messages`（Claude Code では
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080` を設定）。
-  - Codex CLI など、OpenAI Responses API を使うアプリ：`/v1/responses`
-    （[設定方法](docs/DETAILS.md#the-responses-api-and-codex-cli)）。
- **思考（Thinking）の設定：** チャットのメニュー、または連携先アプリの「reasoning effort」で **off、low、medium、high** から選びます。
-  off が最も速く、難しい質問には high が向いています。
- **画像を読み取る：** セットアップ時に「Images?」で yes を選びます。その後、チャットの **Picture** ボタンをクリックするか、連携先のアプリで画像を添付してください。
-  AMD のカードを使う場合、Linux では CPU で画像を読み取ります。Windows ではまだ画像の読み取りに対応していません。
- **スマートフォンや別の PC から使う：** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>` で起動します。API キーは必ず設定してください。
- **リクエストは 1 つずつ：** 標準設定では 1 つずつ処理し、それ以外のリクエストは順番を待ちます。同時に処理するには、
-  `"parallel": 2` を設定してください（[BATCHING.md](docs/BATCHING.md)）。12 GB のカードでは、リクエストごとの回答速度が落ちます。
- **長いプロンプトを送る：** チャットの最初のメッセージは全文を読み込むため、30,000 トークンあたり約 1 分かかります。
-  2 通目以降は数秒で応答が始まります。
-
-[チャットの保存場所](docs/INSTALL.md#where-things-are-stored)や[API の詳細](docs/DETAILS.md#using-it)も参照してください。
-
-### オプション：モデル全体が RAM に収まる場合、GPU 1 枚でさらに高速化
-
-2 つのオプトイン設定です（RubenTorney 氏による #1904 と #1905）。GPU を 1 枚使い、RAM にすべてのエキスパートが収まる場合（Strata の arena モード。例：64 GB の PC で Q2_0 や IQ3_XXS）に効果があります。Strata のデータフォルダーにある設定ファイル `strata-<model>.json`（[場所](docs/INSTALL.md#where-things-are-stored)）を開き、次を追加します：
-
- **生成の高速化：** `"args"` リストに `"--adapt-async", "1"`。エキスパートキャッシュの更新が回答を止めずに補助スレッドで行われます。RTX 5070（Windows、Q2_0）での実測：生成 +4〜5%、コードや長文では +7〜10%。回答はデフォルトとわずかに異なる場合があります（実行ごとには同じです）。
- **Windows でのプロンプト読み込みの高速化：** `"env"` ブロックに `"STRATA_PIN_BY_NEED": "1"`。Windows はGPU 用に RAM の約半分しか固定できないため、この設定で GPU が本当に必要とするエキスパートから先に固定します。RTX 5070 での実測：プロンプト読み込み +4.4%。
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-変更後は Strata を再起動してください（`START-HERE.bat` または `./setup.sh`）。元に戻すには、2 つの項目を削除します。
+Windows では、インストール後に新しいターミナルを開きます。そのあと:

-## うまくいかないとき
+```sh
+strata launch
+```

- **初回起動時に PC が応答しなくなる。** モデルの読み込み中は、一時的に応答しなくなることがあります。ウィンドウを閉じずにお待ちください。
-  10 分たっても応答しない場合は、PC を再起動して他のアプリを閉じてからやり直すか、モデルのサイズを小さくしてください。
- **ダウンロードやインストールが途中で止まる。** `START-HERE.bat`（または `./setup.sh`）をもう一度実行してください。
-  中断したところから再開できます。
- **動作が極端に遅く、ディスクのアクセスランプが点滅し続ける。または「the engine stopped unexpectedly」と表示される。** RAM の空き容量が不足しています。
-  ブラウザーなど、RAM を多く使う他のアプリを閉じるか、小さいモデル（Q2_0 または IQ2_XS）を選んでください。
- **ポート 8080 が使用中と表示される。** Strata がすでに起動しています。起動済みのウィンドウを探してください。
+画面の案内に従って、モデルをダウンロードして起動します。[ターミナルガイド](docs/TERMINAL_LAUNCH.md)。

-その他の問題と対処方法は、[docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md)をご覧ください。解決しない場合は
-[Issue](https://github.com/Niko1221/Strata/issues) を作成し、Strata フォルダー内の `strata-<model>.log` を添付してください。
-セキュリティ上の問題は、[SECURITY.md](SECURITY.md)の手順に従って非公開で報告してください。
+</details>

-## しくみ
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="モデルの動作、速度、メモリ、最近のリクエストを表示する Strata ターミナルアプリ">
+  <br><sub>動作中のモデルとハードウェアの状態を確認できます。</sub>
+</p>

-この規模のモデルは通常、数百ギガバイトの GPU メモリを搭載したサーバーで動かします。一方、手元のグラフィックカードのメモリは
-12-24 GB 程度です。Strata は **PC 全体で処理を分担する** ことで、こうした環境でもモデルを動かせるようにしています。
-台所で、よく使うものは調理台に置き、それ以外は食品庫にしまっておくような仕組みです。
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="24,576 個のエキスパートのうち、よく使うものをグラフィックカードに配置。全エキスパートは RAM に、ルックアップテーブルは SSD に保持"></p>
+[ソースからビルド](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [インストールガイド（全文）](docs/INSTALL.md)

- **モデルは「エキスパート」と呼ばれる 24,576 個の小さな処理単位から構成されています。** 1 語の生成に必要なのは、このうち 10 個だけです。
- **グラフィックカード** に、使用頻度の高い数千個のエキスパートを置きます。**RAM** にはすべてのエキスパートを保持し、
-  **CPU** が残りの処理を並行して担当します。**SSD** には大きなルックアップテーブルを保存します。
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="小さな補助モデルが次の数語を予測し、大きなモデルがまとめて検証。正しい予測だけを採用する"></p>
+## ハードウェア

- **予測してから検証：** 小さな補助モデルが次の数語を予測し、大きなモデルがまとめて検証します。
-  回答を変えずに、生成速度を 1.6-1.8 倍に高められます。
- **長いテキストはまとめて読み込みます**（一度に最大 8,192 トークン）。読み込み速度は毎秒 1,000 トークンを超えます。
+| 対応ハードウェア | ガイド |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50 シリーズ** | [NVIDIA のセットアップ](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900、RX 9060 / 9070、AI PRO R9700** | [AMD のセットアップ](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · 試験的** | [RX 6000 のセットアップ](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Intel のセットアップ](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 以降** | [Mac のセットアップ](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Strix Halo のセットアップ](docs/STRIX_HALO.md) |

-仕組みについては、[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md)で詳しく説明しています。各処理の詳細や測定値は、
-[技術資料](docs/DETAILS.md#how-it-works)と[論文](docs/paper/Strata-Paper.pdf)をご覧ください。
+<a id="using-it"></a>

-## クレジットとライセンス
+## ツール

-使用しているモデルは、Qwen チームが開発した [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) です。
-[ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)、UkisAI（Swift 1.5）、Unsloth が提供する圧縮版を利用しています。
-Strata は [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) の一部も使用しています。クレジットの一覧は
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits)をご覧ください。Strata は [MIT License](LICENSE) で公開されていますが、一部の構成要素と
-各モデルには、それぞれ別のライセンスが適用されます（[ライセンスの詳細](docs/HOW_IT_WORKS.md#license)）。
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**。OpenAI 互換と Anthropic 互換の API を通じて、ほかのツールも使えます。
+
+**`strata connect`** を実行すると、お使いのツールの設定方法が表示されます。[接続ガイド](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect)。
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## ヘルプ
+
+[すべてのガイド](docs) · [トラブルシューティング](docs/TROUBLESHOOTING.md) · [不具合を報告](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[ベンチマーク](docs/COMMUNITY_BENCHMARKS.md) · [仕組み](docs/HOW_IT_WORKS.md) · [貢献する](CONTRIBUTING.md)

 ## Strata を支援する

-Strata は無料で使えるオープンソースソフトウェアです。役に立ったら、開発へのご支援をお願いします。
+**ローカル AI をみんなに開かれたものに。** コーヒー1杯が、開発と、より多くのハードウェアでのテストの支えになります。

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: Strata を支援する" height="48"></a>
+
+[MIT ライセンス](LICENSE) · [クレジットとモデルのライセンス](docs/HOW_IT_WORKS.md#credits) · [プライバシー](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>AI ツールと自動リーダー向け: <a href="AGENTS.md">技術リファレンス</a> · <a href="docs/AI_SETUP.md">セットアップ手順</a></sub>
+
+**スポンサー、ハードウェア提携、共同開発のご相談:** [[email protected]](mailto:[email protected]).
@@ -1,243 +1,193 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-**English** · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [Deutsch](README.de.md) · [Français](README.fr.md) · [Español](README.es.md) · [Português](README.pt-BR.md)
+<h3 align="center">Run powerful AI on your own computer.</h3>
+<p align="center">Chat, code and work with images, locally.</p>

-<p align="center"><b>Run a 125-billion-parameter AI model on your own gaming PC</b><br>
-NVIDIA or AMD graphics card (12 GB or more) · Windows or Linux · free and open source</p>
+<p align="center">
+  <a href="#models">Models</a> · <a href="#install"><b>Install</b></a> ·
+  <a href="#hardware">Hardware</a> · <a href="#tools">Tools</a> ·
+  <a href="#help">Help</a> · <a href="#support-strata">Support</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="A voxel pagoda garden that Strata's model wrote, running in the browser"></a><br>
-<sub>A voxel pagoda garden, 1 shot prompt running on an RTX 5070 with Strata (IQ3_S, 128K context) ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">full video (49 s)</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Download Strata"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="MIT license"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Support Strata on Buy Me a Coffee"></a>
+</p>

-Strata runs **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** on a normal PC. This is a
-large, smart AI model that usually needs a server. It chats, writes code, reads pictures and works with your apps
-and coding agents. Nothing leaves your PC.
+<p align="center"><sub><b>English</b> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## How fast is it?
+**Free, open source, and yours to run.** Use Strata on your desktop or with your favorite coding tools. No account needed.

-We measured it on two ordinary gaming PCs. A token is about ¾ of a word.
+## Models

- **Writes answers:** how fast the reply appears in a short chat. 60 tokens per second is faster than you can read.
- **Reads your prompt:** how fast it takes in what you send (here a 32K-token document, code or chat history).
+We recommend **ISTA-DASLab first**, then **Unsloth** and other providers, where a compatible model fits.

-<table>
-<tr><th>NVIDIA: RTX 5070 (12 GB), Ryzen 5 7600, 64 GB RAM</th><th>AMD: RX 9070 XT (16 GB), Ryzen 9 3900X, 47 GB RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| Size | Writes answers | Reads your prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| Size | Writes answers | Reads your prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA: Q2_0 with engine 0.1.36, the other rows with 0.1.26 (4K answers, 32K prompts). The full tables are in
-[DETAILS.md](docs/DETAILS.md#speed-measured). A card with more VRAM is faster: an RTX 3090 (24 GB) should write
-about 100-140 tokens per second. Long chats and other cards: [speed of each model](docs/MODELS.md#how-fast-is-each-size),
-[community results](docs/COMMUNITY_BENCHMARKS.md).
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>Strata is free. If it runs well on your PC, a coffee keeps the work on it going.</sub></p>
-
-## What you need
-
-| | |
+| Provider | Choices |
 | --- | --- |
-| **Graphics card** | **NVIDIA** GeForce RTX 20, 30, 40 or 50 series, or **AMD** Radeon RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT, Radeon AI PRO R9700 or RX 6800 / 6900 series. It needs **12 GB of VRAM or more**. |
-| **RAM** | 32 GB or more. Your RAM decides [which model](#which-model-should-i-pick) fits. 64 GB runs every size. |
-| **Disk** | About 80 GB free. Use an SSD if you can: the first start is much faster. |
-| **System** | Windows 10 / 11 or Linux, and a current graphics driver from NVIDIA or AMD. |
+| **ISTA-DASLab · recommended** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder: IQ1\_M](docs/MODELS.md#coder) for coding. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Lower memory use but slower. |
+| **Other options** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-The installer sets up everything else. Two or three cards can share the model ([multi-GPU](docs/MULTI_GPU.md)).
+[Compare sizes, memory needs and compatibility](docs/MODELS.md).

-Experimental, written and tested by community members on their own machines:
+</details>

- **Older graphics cards** (Tesla P40 / V100, GTX 10, Radeon VII / MI50, RX 6700 XT, RX 5500 XT): [Older GPUs](docs/OLDER_GPUS.md).
- **Intel Arc**, built from source on Linux: [Intel Arc](docs/INTEL_ARC.md).
- **Apple Silicon Macs (M1 to M5)**, built from source by `./setup.sh` (the Metal engine): [Mac](docs/MAC.md).
- **AMD Ryzen AI Max (Strix Halo)**, built from source on Linux: [Strix Halo](docs/STRIX_HALO.md).
- **Older processors without AVX2**: they work, but slowly. [Older CPUs](docs/INSTALL.md#older-cpus-experimental).
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-The full list: [docs/INSTALL.md](docs/INSTALL.md#what-you-need).
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. These are the currently documented packs for this model.
+
+[Model guide and compatibility](docs/QWEN36.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+In the **desktop app** and the **Terminal**. What does not fit in memory is read from your SSD, so it needs a lot of free
+disk space.
+
+| Set (IST-DAS) | Download | Free disk needed |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | about 245 GB |
+| 2.00 bpw | 257 GB | about 265 GB |
+| 2.25 bpw | 274 GB | about 280 GB |
+
+Runs on NVIDIA RTX 30, 40 and 50 series (Windows and Linux), AMD Radeon AI PRO R9700 (Linux), and AMD Ryzen AI Max — Strix Halo
+(Windows). Setup downloads the files and the DeepSeek engine, then starts the model.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Measured with the 2.00 bpw set on Strata 0.2.5 (Strix Halo: 0.2.7). Output is the speed of the answer, prompt is how fast Strata reads your input.
+
+| Hardware | Output | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB RAM | 4 to 6 tokens/s | about 110 tokens/s (4K) |
+| RTX 3060 12 GB, 46 GB RAM | 9 to 11 tokens/s | about 155 tokens/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB RAM | 21 to 25 tokens/s | 320 to 360 tokens/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 to 77 tokens/s | 400 to 450 tokens/s (8K) |
+| Ryzen AI Max+ 395 (Strix Halo), 128 GB unified | 19 to 21 tokens/s (code), 11 (chat) | 87 tokens/s (4K), 125 tokens/s (8K) |
+
+[Memory, disk and details](docs/DEEPSEEK41.md) · [Release notes](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+Not sure what fits? [Choose a model for your computer](docs/MODELS.md#pick-by-memory).

 ## Install

-### Let your AI set it up
+<a id="option-a-the-strata-app"></a>

-Do you use an AI coding assistant (Claude Code, Cursor, Codex, GitHub Copilot, ...)? Paste this into it:
+### Desktop app

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[Download Strata for Windows, Linux or Mac →](https://github.com/Niko1221/Strata/releases/latest)**
+
+Install the app, choose a model, and start chatting. There is one installer for each system. On first start the app
+downloads the engine for your graphics card. [Help with the installer](docs/INSTALL.md#the-app).
+
+<sub>Files: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Strata desktop app with a chat and live code preview side by side">
+  <br><sub>Chat, files and a live preview in one window.</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### Terminal app
+
+Prefer the terminal? Install Strata, then run **`strata launch`**.
+
+<details open>
+<summary><b>Install commands</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-It checks your graphics card, RAM and disk and picks the model that fits. Then it installs and starts it and tells
-you how to connect your apps. AI tools can also install, start and stop Strata through its
-[MCP server](docs/MCP_SERVER.md).
+**Windows PowerShell**

-### Or do it yourself
-
-[Download Strata](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) and unzip it (or `git clone` it).
-**Windows:** double-click **`START-HERE.bat`**. **Linux:** run **`./setup.sh`** in the Strata folder.
-
-**Mac (Apple Silicon, M1 to M5, macOS 15 or newer):** install Apple's Command Line Tools once
-(`xcode-select --install` in Terminal; Xcode itself is not needed). Then open Terminal in the Strata folder and run
-**`./setup.sh`**. It builds the Mac engine on your Mac (about 7 minutes), asks the same questions, downloads the model
-and starts it. Next time, `./setup.sh` starts it right away. Which size fits your Mac and how fast it is:
-[docs/MAC.md](docs/MAC.md).
-
-The steps are the same for NVIDIA and AMD. The installer finds your card and sets up the right engine for it. It
-asks you a few questions:
-
- which model and which size,
- how much context (how much text the model keeps in mind),
- whether it should read pictures.
-
-Press Enter each time for the recommended answer. Then it downloads the model (about 70 GB) and starts it. If the
-download stops, run it again: it continues where it left off. Your browser opens the Strata app at
-`http://127.0.0.1:8080`.
-
-> **While the model starts, your PC can be slow or stop responding for 1-3 minutes** (longest the first time).
-> Strata loads 35-55 GB into your RAM and locks part of it for the graphics card. This is normal. Wait, and don't
-> close the window. The window shows what Strata is doing.
-
-**Next time**, run `START-HERE.bat` (or `./setup.sh`) again. It starts right away and downloads nothing twice. Close
-its window to stop the model. `UPDATE.bat` (`./update.sh`) updates Strata without starting it. Updating, Docker,
-several cards, where the files go and every option: [docs/INSTALL.md](docs/INSTALL.md).
-
-**Is it fast on your PC?** Run `BENCH.bat` (`./bench.sh`): about 5-10 minutes, it measures chat, 4K/16K prompts and an agent-style session with your own settings and writes a report to share ([how](docs/COMMUNITY_BENCHMARKS.md#run-the-benchmark)).
-
-## Which model should I pick?
-
-The installer recommends one for your RAM. The same model comes in several sizes, compressed more or less. Smaller
-sizes are faster. Larger sizes are a bit smarter.
-
-| Your RAM | Take | Why |
-| --- | --- | --- |
-| **32 GB** | **Coder** | it fits 32 GB, and it is made for code (with a 24 GB card, Q2_0 and IQ2_XS run too) |
-| **48 GB** | **IQ2_XS** (or Q2_0, the fastest) | the larger sizes do not fit |
-| **64 GB** | **IQ2_XS** (recommended), or IQ3_XXS / IQ3_S | every size fits; IQ3_S is the best and the slowest |
-| **96 GB or more** | **IQ3_S**, or Unsloth's UD-IQ4_XS (~4-bit) | room for the largest sizes with everything else open |
-
- **[Coder](docs/MODELS.md#coder):** a coding version with half of the experts removed. It reaches 91% of the full
-  model's SWE-bench Verified score (measured by its authors) and fits 32 GB of RAM. It is weaker outside code,
-  including Chinese and other CJK text (#438). For those, take Q2_0, IQ2_XS or IQ3_S, which keep every expert.
- **[Swift 1.5](docs/MODELS.md#swift-15):** a fine-tune that thinks for a much shorter time before it answers. You
-  get the answer sooner, at about the same quality.
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs):** Unsloth's ~4-bit version, between IQ3_S and
-  UD-Q4_K_XL in quality. A 94 GB download. With less than ~80 GB of RAM, Strata reads part of it from the SSD
-  while it answers, so it is slower there (an NVMe SSD helps).
- **[Unsloth UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL and Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0):**
-  4- to 8-bit, closer to the full model (93-95% the same next token as Q8_0). Fast where every expert fits in RAM
-  (~88 GB for UD-Q4_K_XL up to ~136 GB for Q8_0); with less RAM Strata reads part of them from the SSD while it
-  answers, which is much slower (7-8.5 tokens/s for UD-Q4_K_XL on a 64 GB PC).
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs):** you set it up by hand. It is
-  not in the installer's menu.
-
-Sizes, downloads and what fits where: [docs/MODELS.md](docs/MODELS.md). To add another model later, run
-`SETUP.bat` (Linux: `./setup.sh --setup`).
-
-## Using it
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="The Strata app's Monitor tab next to a coding agent"><br>
-<sub>The Strata app's <b>Monitor</b> (left) while a coding agent writes the pagoda garden from the video (right)</sub></p>
-
- **In the browser:** open `http://127.0.0.1:8080`. It has **Chat**, a live **Monitor** of the model and your
-  GPU/CPU/RAM, and **About** with the settings and addresses.
- **Your apps and coding agents:** add an "OpenAI-compatible" provider with the base URL
-  **`http://127.0.0.1:8080/v1`**. Any API key and any model name work.
-  - Apps that use Anthropic's API: `http://127.0.0.1:8080/v1/messages` (Claude Code:
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`).
-  - Codex CLI and other apps that use the OpenAI Responses API: `/v1/responses`
-    ([setup](docs/DETAILS.md#the-responses-api-and-codex-cli)).
- **Thinking:** choose **off, low, medium or high** in the chat menu or in your app's "reasoning effort". Off is the
-  fastest. High is best for hard questions.
- **Pictures:** say yes to "Images?" in setup. Then click **Picture** in the chat, or attach pictures in your app.
-  AMD cards read pictures on Linux through the processor; on Windows they can't yet.
- **From your phone or another PC:** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`. Always set a key.
- **One request at a time:** by default Strata answers one request, and the others wait. To answer several at once,
-  set `"parallel": 2` ([BATCHING.md](docs/BATCHING.md)). On a 12 GB card this makes each answer slower.
- **Long prompts:** Strata reads the first message of a chat in full, about 1 minute per 30,000 tokens. Follow-up
-  messages start in seconds.
-
-More: [where your chats are stored](docs/INSTALL.md#where-things-are-stored), [the API](docs/DETAILS.md#using-it).
-
-### Optional: more speed on one card when the whole model fits in RAM
-
-Two opt-in settings (by RubenTorney, #1904 and #1905). They help when you run one graphics card and your RAM holds
-every expert (Strata's arena mode, for example Q2_0 or IQ3_XXS on a 64 GB PC). Open your config,
-`strata-<model>.json` in the Strata data folder ([where](docs/INSTALL.md#where-things-are-stored)), and add:
-
- **Faster decode:** `"--adapt-async", "1"` to the `"args"` list. The expert cache then updates on a helper thread
-  instead of pausing the answer. Measured on an RTX 5070 (Windows, Q2_0): +4-5% decode, +7-10% on code and long
-  documents. Answers can differ slightly from the default (they stay the same from run to run).
- **Faster prompt reading on Windows:** `"STRATA_PIN_BY_NEED": "1"` in the `"env"` block. Windows can lock only about
-  half the RAM for the graphics card; this locks the experts the card actually needs first. Measured on the RTX 5070:
-  +4.4% prompt reading.
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-Restart Strata (`START-HERE.bat` or `./setup.sh`) after the change. To undo, remove the two entries.
+On Windows, open a new terminal afterwards. Then:

-## Something went wrong?
+```sh
+strata launch
+```

- **My PC froze the first time Strata started.** This is normal while it loads the model. Wait, and don't close the
-  window. Still frozen after 10 minutes? Restart the PC, close other programs and try again, or pick a smaller size.
- **It stopped while downloading or installing.** Run `START-HERE.bat` (or `./setup.sh`) again. It continues where
-  it stopped.
- **It's very slow and the disk light keeps blinking, or it says "the engine stopped unexpectedly".** Your PC does
-  not have enough free RAM. Close other programs (browsers use a lot), or pick a smaller size (Q2_0 or IQ2_XS).
- **It says port 8080 is already in use.** Strata is already running. Look for its window.
+Follow the prompts to download and start a model. [Terminal guide](docs/TERMINAL_LAUNCH.md).

-More problems and their fixes: [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md). Still stuck? Open an
-[issue](https://github.com/Niko1221/Strata/issues) and attach `strata-<model>.log` from the Strata folder. Found a
-security problem? Report it privately: [SECURITY.md](SECURITY.md).
+</details>

-## How does it work?
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Strata terminal app showing model activity, speed, memory and recent requests">
+  <br><sub>Watch your model and hardware while it runs.</sub>
+</p>

-Models like this one usually run on servers with hundreds of gigabytes of graphics memory. Your graphics card has
-12-24 GB. Strata makes the model fit by **sharing the work across your whole PC**. Think of a kitchen: the things
-you use all the time stay on the counter, and the rest waits in the pantry.
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="The model's 24,576 experts: the busiest on the graphics card, all of them in RAM, a lookup table on the SSD"></p>
+[Build from source](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Full install guide](docs/INSTALL.md)

- **The model is a team of 24,576 small specialists ("experts").** Each word needs only 10 of them.
- **Your graphics card** keeps the few thousand experts that are used most often. **Your RAM** holds all of them,
-  and **your processor** works on the rest at the same time. **Your SSD** holds a big lookup table.
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="A small helper guesses the next words; the big model checks them all at once and keeps the right ones"></p>
+## Hardware

- **Guess, then check:** a small helper guesses the next few words. The big model checks them all at once. You get
-  the same answer, 1.6-1.8x sooner.
- **Long texts are read in big pieces** (up to 8,192 tokens at a time), at over 1,000 tokens per second.
+| Supported hardware | Guide |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50 series** | [NVIDIA setup](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [AMD setup](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · experimental** | [RX 6000 setup](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Intel setup](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 or newer** | [Mac setup](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Strix Halo setup](docs/STRIX_HALO.md) |

-The longer explanation: [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md). Every part and its numbers:
-[the details](docs/DETAILS.md#how-it-works) and the [paper](docs/paper/Strata-Paper.pdf).
+<a id="using-it"></a>

-## Credits and license
+## Tools

-The model is [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next) by the Qwen team. It was
-compressed by [ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), UkisAI (Swift 1.5)
-and Unsloth. Strata uses parts of [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp). All credits:
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits). Strata is open source under the [MIT License](LICENSE). A few
-parts and every model have their own licenses ([which ones](docs/HOW_IT_WORKS.md#license)).
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**, and more through the OpenAI- and Anthropic-compatible APIs.
+
+Run **`strata connect`** to see setup instructions for your tool. [Connection guide](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## Help
+
+[All guides](docs) · [Troubleshooting](docs/TROUBLESHOOTING.md) · [Report a bug](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Benchmarks](docs/COMMUNITY_BENCHMARKS.md) · [How it works](docs/HOW_IT_WORKS.md) · [Contribute](CONTRIBUTING.md)

 ## Support Strata

-Strata is free and open source. If it is useful to you, you can support its development:
+**Help keep local AI open to everyone.** A coffee helps fund development and testing on more hardware.
+
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: support Strata" height="48"></a>
+
+[MIT license](LICENSE) · [Credits and model licenses](docs/HOW_IT_WORKS.md#credits) · [Privacy](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>For AI tools and automated readers: <a href="AGENTS.md">technical reference</a> · <a href="docs/AI_SETUP.md">setup instructions</a>.</sub>
+
+**Sponsorships, hardware partnerships or collaborations:** [[email protected]](mailto:[email protected]).

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
@@ -0,0 +1,192 @@
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>
+
+<h3 align="center">Uruchom potężną sztuczną inteligencję na własnym komputerze.</h3>
+<p align="center">Rozmawiaj, programuj i pracuj z obrazami — lokalnie.</p>
+
+<p align="center">
+  <a href="#modele">Modele</a> · <a href="#instalacja"><b>Instalacja</b></a> ·
+  <a href="#sprzęt">Sprzęt</a> · <a href="#narzędzia">Narzędzia</a> ·
+  <a href="#pomoc">Pomoc</a> · <a href="#wesprzyj-stratę">Wsparcie</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Pobierz Stratę"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="Licencja MIT"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Wesprzyj Stratę na Buy Me a Coffee"></a>
+</p>
+
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <b>Polski</b></sub></p>
+
+**Bezpłatna, z otwartym kodem źródłowym i do uruchomienia u siebie.** Używaj Straty na swoim komputerze albo razem z ulubionymi narzędziami do programowania. Konto nie jest potrzebne.
+
+## Modele
+
+Najpierw polecamy **ISTA-DASLab**, potem **Unsloth** i innych dostawców — o ile zgodny model mieści się w pamięci.
+
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>
+
+| Dostawca | Do wyboru |
+| --- | --- |
+| **ISTA-DASLab · polecany** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder: IQ1\_M](docs/MODELS.md#coder) do programowania. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Zużywa mniej pamięci, ale działa wolniej. |
+| **Inne opcje** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |
+
+[Porównaj rozmiary, wymagania pamięciowe i zgodność](docs/MODELS.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>
+
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. To obecnie udokumentowane pakiety dla tego modelu.
+
+[Przewodnik po modelu i zgodność](docs/QWEN36.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+W **aplikacji na komputer** i w **Terminalu**. To, co nie mieści się w pamięci, jest czytane z dysku SSD, więc potrzebujesz
+dużo wolnego miejsca na dysku.
+
+| Zestaw (IST-DAS) | Do pobrania | Potrzebne wolne miejsce |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | około 245 GB |
+| 2.00 bpw | 257 GB | około 265 GB |
+| 2.25 bpw | 274 GB | około 280 GB |
+
+Działa na kartach NVIDIA RTX serii 30, 40 i 50 (Windows i Linux), AMD Radeon AI PRO R9700 (Linux) oraz AMD Ryzen AI Max — Strix Halo
+(Windows). Instalacja pobiera pliki i silnik DeepSeek, a potem uruchamia model.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Zmierzone na zestawie 2.00 bpw w Strata 0.2.5 (Strix Halo: 0.2.7). „Wyjście” to szybkość odpowiedzi, „prompt” — jak szybko Strata czyta twój tekst.
+
+| Sprzęt | Wyjście | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB RAM | 4–6 tokenów/s | około 110 tokenów/s (4K) |
+| RTX 3060 12 GB, 46 GB RAM | 9–11 tokenów/s | około 155 tokenów/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB RAM | 21–25 tokenów/s | 320–360 tokenów/s (8K) |
+| 4x Radeon AI PRO R9700 | 74–77 tokenów/s | 400–450 tokenów/s (8K) |
+| Ryzen AI Max+ 395 (Strix Halo), 128 GB pamięci współdzielonej | 19–21 tokenów/s (kod), 11 (czat) | 87 tokenów/s (4K), 125 tokenów/s (8K) |
+
+[Pamięć, dysk i szczegóły](docs/DEEPSEEK41.md) · [Informacje o wydaniach](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+Nie wiesz, co się zmieści? [Wybierz model do swojego komputera](docs/MODELS.md#pick-by-memory).
+
+## Instalacja
+
+<a id="option-a-the-strata-app"></a>
+
+### Aplikacja na komputer
+
+**[Pobierz Stratę dla Windows, Linuxa lub Maca →](https://github.com/Niko1221/Strata/releases/latest)**
+
+Zainstaluj aplikację, wybierz model i zacznij rozmawiać. Dla każdego systemu jest jeden instalator. Przy pierwszym
+uruchomieniu aplikacja pobiera silnik dla twojej karty graficznej. [Pomoc z instalatorem](docs/INSTALL.md#the-app).
+
+<sub>Pliki: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Aplikacja Strata na komputer: czat i podgląd kodu na żywo obok siebie">
+  <br><sub>Czat, pliki i podgląd na żywo w jednym oknie.</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### Aplikacja Terminal
+
+Wolisz terminal? Zainstaluj Stratę, a potem uruchom **`strata launch`**.
+
+<details open>
+<summary><b>Polecenia instalacji</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
+```
+
+**Windows PowerShell**
+
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
+```
+
+W Windows otwórz potem nowe okno terminala. Następnie:
+
+```sh
+strata launch
+```
+
+Postępuj zgodnie z podpowiedziami, aby pobrać i uruchomić model. [Przewodnik po Terminalu](docs/TERMINAL_LAUNCH.md).
+
+</details>
+
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Aplikacja Terminal Straty pokazująca aktywność modelu, szybkość, pamięć i ostatnie zapytania">
+  <br><sub>Obserwuj model i sprzęt w trakcie pracy.</sub>
+</p>
+
+<a id="build-from-source"></a>
+
+[Budowanie ze źródeł](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Pełny przewodnik instalacji](docs/INSTALL.md)
+
+<a id="what-you-need"></a>
+
+## Sprzęt
+
+| Obsługiwany sprzęt | Przewodnik |
+| --- | --- |
+| **NVIDIA GeForce RTX serii 20 / 30 / 40 / 50** | [Konfiguracja NVIDIA](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [Konfiguracja AMD](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · eksperymentalnie** | [Konfiguracja RX 6000](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Konfiguracja Intel](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 lub nowszy** | [Konfiguracja Mac](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Konfiguracja Strix Halo](docs/STRIX_HALO.md) |
+
+<a id="using-it"></a>
+
+## Narzędzia
+
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw** i inne — przez API zgodne z OpenAI i Anthropic.
+
+Uruchom **`strata connect`**, aby zobaczyć instrukcję konfiguracji dla swojego narzędzia. [Przewodnik po połączeniach](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## Pomoc
+
+[Wszystkie przewodniki](docs) · [Rozwiązywanie problemów](docs/TROUBLESHOOTING.md) · [Zgłoś błąd](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Testy wydajności](docs/COMMUNITY_BENCHMARKS.md) · [Jak to działa](docs/HOW_IT_WORKS.md) · [Współtworzenie](CONTRIBUTING.md)
+
+## Wesprzyj Stratę
+
+**Pomóż zachować lokalną sztuczną inteligencję otwartą dla wszystkich.** Kawa pomaga finansować rozwój i testy na większej liczbie sprzętu.
+
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: wesprzyj Stratę" height="48"></a>
+
+[Licencja MIT](LICENSE) · [Podziękowania i licencje modeli](docs/HOW_IT_WORKS.md#credits) · [Prywatność](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>Dla narzędzi AI i automatycznych czytników: <a href="AGENTS.md">dokumentacja techniczna</a> · <a href="docs/AI_SETUP.md">instrukcja instalacji</a>.</sub>
+
+**Sponsoring, partnerstwa sprzętowe i współpraca:** [[email protected]](mailto:[email protected]).
@@ -1,234 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · [简体中文](README.zh-CN.md) · [日本語](README.ja.md) · [Deutsch](README.de.md) · [Français](README.fr.md) · [Español](README.es.md) · **Português**
+<h3 align="center">IA poderosa no seu próprio computador.</h3>
+<p align="center">Converse, programe e trabalhe com imagens, localmente.</p>

-<p align="center"><b>Rode um modelo de IA de 125 bilhões de parâmetros no seu próprio PC gamer</b><br>
-Placa de vídeo NVIDIA ou AMD (12 GB ou mais) · Windows ou Linux · gratuito e de código aberto</p>
+<p align="center">
+  <a href="#modelos">Modelos</a> · <a href="#instalação"><b>Instalação</b></a> ·
+  <a href="#hardware">Hardware</a> · <a href="#ferramentas">Ferramentas</a> ·
+  <a href="#ajuda">Ajuda</a> · <a href="#apoie-o-strata">Apoiar</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Um jardim com pagode em voxels que o modelo do Strata escreveu, rodando no navegador"></a><br>
-<sub>Um jardim com pagode em voxels, feito com um único prompt numa RTX 5070 com o Strata (IQ3_S, contexto de 128K) ·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">vídeo completo (49 s)</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="Baixar o Strata"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="Licença MIT"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="Apoie o Strata no Buy Me a Coffee"></a>
+</p>

-O Strata roda o **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)** num PC comum. É um modelo
-de IA grande e inteligente que normalmente precisa de um servidor. Ele conversa, escreve código, entende imagens e
-funciona com seus apps e agentes de programação. Nada sai do seu PC.
+<p align="center"><sub><a href="README.md">English</a> · <a href="README.zh-CN.md">简体中文</a> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <b>Português</b> · <a href="README.pl.md">Polski</a></sub></p>

-## Qual é a velocidade?
+**Gratuito, de código aberto e seu para executar.** Use o Strata no desktop ou com suas ferramentas de programação favoritas. Não precisa de conta.

-Medimos em dois PCs gamer comuns. Um token equivale a cerca de ¾ de uma palavra.
+## Modelos

- **Escreve respostas:** a velocidade com que a resposta aparece numa conversa curta. 60 tokens por segundo é mais rápido do que você consegue ler.
- **Lê seu prompt:** a velocidade com que ele absorve o que você envia (aqui, um documento, código ou histórico de conversa de 32K tokens).
+Recomendamos **primeiro a ISTA-DASLab**, depois a **Unsloth** e outros provedores, quando um modelo compatível cabe na memória.

-<table>
-<tr><th>NVIDIA: RTX 5070 (12 GB), Ryzen 5 7600, 64 GB de RAM</th><th>AMD: RX 9070 XT (16 GB), Ryzen 9 3900X, 47 GB de RAM</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| Tamanho | Escreve respostas | Lê seu prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| Tamanho | Escreve respostas | Lê seu prompt |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA: Q2_0 com o engine 0.1.36, as outras linhas com 0.1.26 (respostas de 4K, prompts de 32K). As tabelas
-completas estão em [DETAILS.md](docs/DETAILS.md#speed-measured). Uma placa com mais VRAM é mais rápida: uma
-RTX 3090 (24 GB) deve escrever cerca de 100-140 tokens por segundo. Conversas longas e outras placas:
-[velocidade de cada modelo](docs/MODELS.md#how-fast-is-each-size), [resultados da comunidade](docs/COMMUNITY_BENCHMARKS.md).
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a><br>
-<sub>O Strata é gratuito. Se ele roda bem no seu PC, um café ajuda a manter o trabalho nele.</sub></p>
-
-## Do que você precisa
-
-| | |
+| Provedor | Opções |
 | --- | --- |
-| **Placa de vídeo** | **NVIDIA** GeForce RTX séries 20, 30, 40 ou 50, ou **AMD** Radeon RX 7900 XT / XTX, RX 7800 XT / 7700 XT, RX 9060 XT, RX 9070 / 9070 XT, Radeon AI PRO R9700 ou séries RX 6800 / 6900. Ela precisa de **12 GB de VRAM ou mais**. |
-| **RAM** | 32 GB ou mais. Sua RAM decide [qual modelo](#qual-modelo-devo-escolher) cabe. Com 64 GB, roda qualquer tamanho. |
-| **Disco** | Cerca de 80 GB livres. Use um SSD se puder: a primeira inicialização fica bem mais rápida. |
-| **Sistema** | Windows 10 / 11 ou Linux, e um driver de vídeo atualizado da NVIDIA ou da AMD. |
+| **ISTA-DASLab · recomendado** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S. [Coder: IQ1\_M](docs/MODELS.md#coder) para programar. |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF). Usa menos memória, mas é mais lento. |
+| **Outras opções** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-O instalador cuida de todo o resto. Duas ou três placas podem dividir o modelo ([multi-GPU](docs/MULTI_GPU.md)).
+[Compare tamanhos, necessidades de memória e compatibilidade](docs/MODELS.md).

-Experimental, escrito e testado por membros da comunidade nas próprias máquinas:
+</details>

- **Placas de vídeo mais antigas** (Tesla P40 / V100, GTX 10, Radeon VII / MI50, RX 6700 XT, RX 5500 XT): [Older GPUs](docs/OLDER_GPUS.md).
- **Intel Arc**, compilado a partir do código-fonte no Linux: [Intel Arc](docs/INTEL_ARC.md).
- **AMD Ryzen AI Max (Strix Halo)**, compilado a partir do código-fonte no Linux: [Strix Halo](docs/STRIX_HALO.md).
- **Processadores mais antigos sem AVX2**: funcionam, mas devagar. [Older CPUs](docs/INSTALL.md#older-cpus-experimental).
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-A lista completa: [docs/INSTALL.md](docs/INSTALL.md#what-you-need).
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0. Esses são os pacotes documentados atualmente para este modelo.
+
+[Guia do modelo e compatibilidade](docs/QWEN36.md).
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+No **aplicativo de desktop** e no **Terminal**. O que não cabe na memória é lido do seu SSD, por isso é preciso muito espaço livre em disco.
+
+| Conjunto (IST-DAS) | Download | Espaço livre necessário |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | cerca de 245 GB |
+| 2.00 bpw | 257 GB | cerca de 265 GB |
+| 2.25 bpw | 274 GB | cerca de 280 GB |
+
+Roda em NVIDIA RTX 30, 40 e 50 (Windows e Linux) e em AMD Radeon AI PRO R9700 (Linux). A instalação baixa os arquivos e o motor do DeepSeek e depois inicia o modelo.
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+Medido com o conjunto de 2.00 bpw no Strata 0.2.5. “Saída” é a velocidade da resposta; “Prompt” é a rapidez com que o Strata lê o seu texto.
+
+| Hardware | Saída | Prompt |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB de RAM | 4 a 6 tokens/s | cerca de 110 tokens/s (4K) |
+| RTX 3060 12 GB, 46 GB de RAM | 9 a 11 tokens/s | cerca de 155 tokens/s (4K) |
+| 1x Radeon AI PRO R9700, 251 GB de RAM | 21 a 25 tokens/s | 320 a 360 tokens/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 a 77 tokens/s | 400 a 450 tokens/s (8K) |
+
+[Memória, disco e detalhes](docs/DEEPSEEK41.md) · [Notas da versão](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+Não sabe o que cabe? [Escolha um modelo para o seu computador](docs/MODELS.md#pick-by-memory).

 ## Instalação

-### Deixe sua IA instalar
+<a id="option-a-the-strata-app"></a>

-Você usa um assistente de programação com IA (Claude Code, Cursor, Codex, GitHub Copilot, ...)? Cole isto nele:
+### Aplicativo de desktop

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[Baixar o Strata para Windows, Linux ou Mac →](https://github.com/Niko1221/Strata/releases/latest)**
+
+Instale o aplicativo, escolha um modelo e comece a conversar. Há um instalador por sistema. Na primeira vez que abre, o aplicativo baixa o motor da sua placa de vídeo. [Ajuda com o instalador](docs/INSTALL.md#the-app).
+
+<sub>Arquivos: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Aplicativo de desktop do Strata com um chat e uma prévia do código ao vivo lado a lado">
+  <br><sub>Chat, arquivos e prévia ao vivo em uma só janela.</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### Aplicativo de Terminal
+
+Prefere o terminal? Instale o Strata e execute **`strata launch`**.
+
+<details open>
+<summary><b>Comandos de instalação</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-Ele verifica sua placa de vídeo, RAM e disco e escolhe o modelo que cabe. Depois instala, inicia e explica como
-conectar seus apps. Ferramentas de IA também podem instalar, iniciar e parar o Strata pelo
-[servidor MCP](docs/MCP_SERVER.md) dele.
+**Windows PowerShell**

-### Ou faça você mesmo
-
-[Baixe o Strata](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) e descompacte (ou use `git clone`).
-**Windows:** clique duas vezes em **`START-HERE.bat`**. **Linux:** rode **`./setup.sh`** na pasta do Strata.
-
-**Mac (Apple Silicon, M1 a M5, macOS 15 ou mais recente):** instale uma vez as Command Line Tools da Apple (`xcode-select --install` no Terminal; o Xcode em si não é necessário). Depois abra o Terminal na pasta do Strata e rode **`./setup.sh`**. Ele compila o motor do Mac no seu Mac (uns 7 minutos), faz as mesmas perguntas, baixa o modelo e o inicia. Da próxima vez, `./setup.sh` inicia na hora. Qual tamanho cabe no seu Mac e qual a velocidade: [docs/MAC.md](docs/MAC.md).
-
-Os passos são os mesmos para NVIDIA e AMD. O instalador encontra sua placa e configura o engine certo para ela.
-Ele faz algumas perguntas:
-
- qual modelo e qual tamanho,
- quanto contexto (quanto texto o modelo guarda na memória),
- se ele deve entender imagens.
-
-Aperte Enter em cada uma para usar a resposta recomendada. Depois ele baixa o modelo (cerca de 70 GB) e o inicia.
-Se o download parar, rode de novo: ele continua de onde parou. Seu navegador abre o app do Strata em
-`http://127.0.0.1:8080`.
-
-> **Enquanto o modelo inicia, seu PC pode ficar lento ou parar de responder por 1-3 minutos** (mais na primeira vez).
-> O Strata carrega 35-55 GB na sua RAM e reserva parte dela para a placa de vídeo. Isso é normal. Espere e não
-> feche a janela. A janela mostra o que o Strata está fazendo.
-
-**Da próxima vez**, rode `START-HERE.bat` (ou `./setup.sh`) de novo. Ele inicia na hora e não baixa nada duas
-vezes. Feche a janela para parar o modelo. `UPDATE.bat` (`./update.sh`) atualiza o Strata sem iniciá-lo.
-Atualização, Docker, várias placas, onde ficam os arquivos e todas as opções: [docs/INSTALL.md](docs/INSTALL.md).
-
-## Qual modelo devo escolher?
-
-O instalador recomenda um de acordo com sua RAM. O mesmo modelo vem em vários tamanhos, mais ou menos comprimidos.
-Os tamanhos menores são mais rápidos. Os maiores são um pouco mais inteligentes.
-
-| Sua RAM | Escolha | Por quê |
-| --- | --- | --- |
-| **32 GB** | **Coder** | cabe em 32 GB e é feito para código (com uma placa de 24 GB, Q2_0 e IQ2_XS também rodam) |
-| **48 GB** | **IQ2_XS** (ou Q2_0, o mais rápido) | os tamanhos maiores não cabem |
-| **64 GB** | **IQ2_XS** (recomendado), ou IQ3_XXS / IQ3_S | todos os tamanhos cabem; IQ3_S é o melhor e o mais lento |
-| **96 GB ou mais** | **IQ3_S**, ou o UD-IQ4_XS da Unsloth (~4-bit) | espaço para os maiores tamanhos com todo o resto aberto |
-
- **[Coder](docs/MODELS.md#coder):** uma versão para programação com metade dos experts removida. Ela alcança 91%
-  da pontuação do modelo completo no SWE-bench Verified (medido pelos autores) e cabe em 32 GB de RAM. É mais fraca
-  fora do código, inclusive em chinês e outros textos CJK (#438). Para isso, escolha Q2_0, IQ2_XS ou IQ3_S, que
-  mantêm todos os experts.
- **[Swift 1.5](docs/MODELS.md#swift-15):** um fine-tune que pensa por bem menos tempo antes de responder. Você
-  recebe a resposta mais cedo, com quase a mesma qualidade.
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs):** a versão de ~4 bits da Unsloth, entre IQ3_S e
-  UD-Q4_K_XL em qualidade. Um download de 94 GB. Com menos de ~80 GB de RAM, o Strata lê uma parte dele do SSD
-  enquanto responde, então ali ele fica mais lento (um SSD NVMe ajuda).
- **[Unsloth UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL e Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0):** de 4 a 8 bits, mais próximos do modelo
-  completo (93-95% o mesmo próximo token que o Q8_0). Rápidos quando todos os especialistas cabem na RAM (~88 GB para
-  o UD-Q4_K_XL até ~136 GB para o Q8_0); com menos RAM, o Strata lê uma parte do SSD enquanto responde, o que é bem
-  mais lento (7-8.5 tokens/s para o UD-Q4_K_XL num PC com 64 GB).
- **[OrcaRouter's Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs):** você configura à mão. Ele
-  não está no menu do instalador.
-
-Tamanhos, downloads e o que cabe onde: [docs/MODELS.md](docs/MODELS.md). Para adicionar outro modelo depois, rode
-`SETUP.bat` (Linux: `./setup.sh --setup`).
-
-## Como usar
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="A aba Monitor do app Strata ao lado de um agente de programação"><br>
-<sub>O <b>Monitor</b> do app Strata (à esquerda) enquanto um agente de programação escreve o jardim com pagode do vídeo (à direita)</sub></p>
-
- **No navegador:** abra `http://127.0.0.1:8080`. Lá tem o **Chat**, um **Monitor** ao vivo do modelo e da sua
-  GPU/CPU/RAM, e o **About** com as configurações e os endereços.
- **Seus apps e agentes de programação:** adicione um provedor "OpenAI-compatible" com a URL base
-  **`http://127.0.0.1:8080/v1`**. Qualquer chave de API e qualquer nome de modelo funcionam.
-  - Apps que usam a API da Anthropic: `http://127.0.0.1:8080/v1/messages` (Claude Code:
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`).
-  - Codex CLI e outros apps que usam a OpenAI Responses API: `/v1/responses`
-    ([configuração](docs/DETAILS.md#the-responses-api-and-codex-cli)).
- **Raciocínio:** escolha **off, low, medium ou high** no menu do chat ou no "reasoning effort" do seu app. Off é o
-  mais rápido. High é o melhor para perguntas difíceis.
- **Imagens:** responda sim para "Images?" na instalação. Depois clique em **Picture** no chat, ou anexe imagens no
-  seu app. Placas AMD entendem imagens no Linux usando o processador; no Windows, ainda não.
- **Do seu celular ou de outro PC:** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`. Sempre defina uma chave.
- **Uma requisição por vez:** por padrão, o Strata responde uma requisição e as outras esperam. Para responder
-  várias ao mesmo tempo, defina `"parallel": 2` ([BATCHING.md](docs/BATCHING.md)). Numa placa de 12 GB, isso deixa
-  cada resposta mais lenta.
- **Prompts longos:** o Strata lê a primeira mensagem de uma conversa inteira, cerca de 1 minuto a cada 30,000
-  tokens. As mensagens seguintes começam em segundos.
-
-Mais: [onde suas conversas ficam salvas](docs/INSTALL.md#where-things-are-stored), [a API](docs/DETAILS.md#using-it).
-
-### Opcional: mais velocidade com uma placa quando o modelo inteiro cabe na RAM
-
-Duas configurações opcionais (de RubenTorney, #1904 e #1905). Elas ajudam quando você usa uma placa de vídeo e sua RAM guarda todos os experts (o modo arena do Strata, por exemplo Q2_0 ou IQ3_XXS num PC com 64 GB). Abra sua configuração `strata-<model>.json` na pasta de dados do Strata ([onde](docs/INSTALL.md#where-things-are-stored)) e adicione:
-
- **Geração mais rápida:** `"--adapt-async", "1"` na lista `"args"`. O cache de experts passa a ser atualizado numa thread auxiliar em vez de pausar a resposta. Medido numa RTX 5070 (Windows, Q2_0): +4-5% de geração, +7-10% em código e documentos longos. As respostas podem diferir um pouco do padrão (ficam iguais de uma execução para outra).
- **Leitura do prompt mais rápida no Windows:** `"STRATA_PIN_BY_NEED": "1"` no bloco `"env"`. O Windows só consegue travar cerca de metade da RAM para a placa; isto trava primeiro os experts de que a placa realmente precisa. Medido na RTX 5070: +4,4% na leitura do prompt.
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-Reinicie o Strata (`START-HERE.bat` ou `./setup.sh`) depois da mudança. Para desfazer, remova as duas entradas.
+No Windows, abra um novo terminal depois. Em seguida:

-## Algo deu errado?
+```sh
+strata launch
+```

- **Meu PC travou na primeira vez que o Strata iniciou.** Isso é normal enquanto ele carrega o modelo. Espere e não
-  feche a janela. Ainda travado depois de 10 minutos? Reinicie o PC, feche outros programas e tente de novo, ou
-  escolha um tamanho menor.
- **Parou durante o download ou a instalação.** Rode `START-HERE.bat` (ou `./setup.sh`) de novo. Ele continua de
-  onde parou.
- **Está muito lento e a luz do disco não para de piscar, ou aparece "the engine stopped unexpectedly".** Seu PC
-  não tem RAM livre suficiente. Feche outros programas (navegadores usam muita), ou escolha um tamanho menor (Q2_0
-  ou IQ2_XS).
- **Diz que a porta 8080 já está em uso.** O Strata já está rodando. Procure a janela dele.
+Siga as instruções para baixar e iniciar um modelo. [Guia do Terminal](docs/TERMINAL_LAUNCH.md).

-Mais problemas e como resolver: [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md). Ainda sem solução? Abra uma
-[issue](https://github.com/Niko1221/Strata/issues) e anexe o `strata-<model>.log` da pasta do Strata. Encontrou um
-problema de segurança? Informe em particular: [SECURITY.md](SECURITY.md).
+</details>

-## Como funciona?
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Aplicativo de Terminal do Strata mostrando a atividade do modelo, a velocidade, a memória e as solicitações recentes">
+  <br><sub>Acompanhe seu modelo e seu hardware enquanto ele roda.</sub>
+</p>

-Modelos como este normalmente rodam em servidores com centenas de gigabytes de memória de vídeo. Sua placa de vídeo
-tem 12-24 GB. O Strata faz o modelo caber **dividindo o trabalho pelo PC inteiro**. Pense numa cozinha: o que você
-usa o tempo todo fica na bancada, e o resto espera na despensa.
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="Os 24,576 experts do modelo: os mais usados na placa de vídeo, todos na RAM, uma tabela de consulta no SSD"></p>
+[Compilar a partir do código-fonte](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [Guia de instalação completo](docs/INSTALL.md)

- **O modelo é uma equipe de 24,576 pequenos especialistas ("experts").** Cada palavra precisa de só 10 deles.
- **Sua placa de vídeo** guarda os poucos milhares de experts usados com mais frequência. **Sua RAM** guarda todos
-  eles, e **seu processador** trabalha no resto ao mesmo tempo. **Seu SSD** guarda uma grande tabela de consulta.
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="Um pequeno ajudante adivinha as próximas palavras; o modelo grande confere todas de uma vez e fica com as certas"></p>
+## Hardware

- **Adivinhar e conferir:** um pequeno ajudante adivinha as próximas palavras. O modelo grande confere todas de
-  uma vez. Você recebe a mesma resposta, 1.6-1.8x mais cedo.
- **Textos longos são lidos em grandes pedaços** (até 8,192 tokens por vez), a mais de 1,000 tokens por segundo.
+| Hardware compatível | Guia |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50** | [Instalação para NVIDIA](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900, RX 9060 / 9070, AI PRO R9700** | [Instalação para AMD](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · experimental** | [Instalação para RX 6000](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Instalação para Intel](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 ou mais novo** | [Instalação para Mac](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Instalação para Strix Halo](docs/STRIX_HALO.md) |

-A explicação mais longa: [docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md). Cada parte e seus números:
-[os detalhes](docs/DETAILS.md#how-it-works) e o [artigo](docs/paper/Strata-Paper.pdf).
+<a id="using-it"></a>

-## Créditos e licença
+## Ferramentas

-O modelo é o [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next), da equipe Qwen. Ele foi
-comprimido por [ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF), UkisAI (Swift 1.5)
-e Unsloth. O Strata usa partes do [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp). Todos os créditos:
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits). O Strata é de código aberto sob a [MIT License](LICENSE).
-Algumas partes e todos os modelos têm licenças próprias ([quais](docs/HOW_IT_WORKS.md#license)).
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**, e outras, pelas APIs compatíveis com OpenAI e Anthropic.
+
+Execute **`strata connect`** para ver as instruções da sua ferramenta. [Guia de conexão](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect).
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## Ajuda
+
+[Todos os guias](docs) · [Solução de problemas](docs/TROUBLESHOOTING.md) · [Relatar um bug](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[Benchmarks](docs/COMMUNITY_BENCHMARKS.md) · [Como funciona](docs/HOW_IT_WORKS.md) · [Contribuir](CONTRIBUTING.md)

 ## Apoie o Strata

-O Strata é gratuito e de código aberto. Se ele é útil para você, você pode apoiar o desenvolvimento:
+**Ajude a manter a IA local aberta para todos.** Um café ajuda a financiar o desenvolvimento e os testes em mais hardware.

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" height="50"></a></p>
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee: apoie o Strata" height="48"></a>
+
+[Licença MIT](LICENSE) · [Créditos e licenças dos modelos](docs/HOW_IT_WORKS.md#credits) · [Privacidade](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>Para ferramentas de IA e leitores automáticos: <a href="AGENTS.md">referência técnica</a> · <a href="docs/AI_SETUP.md">instruções de instalação</a>.</sub>
+
+**Patrocínios, parcerias de hardware ou colaborações:** [[email protected]](mailto:[email protected]).
@@ -1,217 +1,188 @@
-<h1 align="center">Strata</h1>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="apps/host/public/brand/strata-lockup-dark.svg">
+    <img src="apps/host/public/brand/strata-lockup-light.svg" alt="Strata" width="340">
+  </picture>
+</p>

-[English](README.md) · **简体中文** · [日本語](README.ja.md) · [Deutsch](README.de.md) · [Français](README.fr.md) · [Español](README.es.md) · [Português](README.pt-BR.md)
+<h3 align="center">在你自己的电脑上运行强大的 AI。</h3>
+<p align="center">本地聊天、写代码、处理图片。</p>

-<p align="center"><b>在你自己的游戏电脑上运行 1250 亿参数的 AI 模型</b><br>
-NVIDIA 或 AMD 显卡（12 GB 及以上）· Windows 或 Linux · 免费开源</p>
+<p align="center">
+  <a href="#模型">模型</a> · <a href="#安装"><b>安装</b></a> ·
+  <a href="#硬件">硬件</a> · <a href="#工具">工具</a> ·
+  <a href="#帮助">帮助</a> · <a href="#支持-strata">支持</a>
+</p>

-<p align="center"><a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4"><img src="docs/media/pagoda-preview.webp" width="720" alt="Strata 的模型写出的体素宝塔花园，在浏览器中运行"></a><br>
-<sub>体素宝塔花园，一次提示生成，在 RTX 5070 上用 Strata 运行（IQ3_S，128K 上下文）·
-<a href="https://github.com/Niko1221/Strata/releases/download/v0.1.10/Pagoda.mp4">完整视频（49 秒）</a></sub></p>
+<p align="center">
+  <a href="https://github.com/Niko1221/Strata/releases/latest"><img src="https://img.shields.io/github/v/release/Niko1221/Strata?label=download&color=0ab887" alt="下载 Strata"></a>
+  <a href="LICENSE"><img src="https://img.shields.io/github/license/Niko1221/Strata" alt="MIT 许可证"></a>
+  <a href="https://buymeacoffee.com/strataengine"><img src="https://img.shields.io/badge/Buy_me_a_coffee-FFDD00?logo=buymeacoffee&logoColor=000" alt="在 Buy Me a Coffee 上支持 Strata"></a>
+</p>

-Strata 能在普通电脑上运行 **[Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)**。这是一个又大又聪明的
-AI 模型，通常要用服务器才能跑。它能聊天、写代码、看图片，还能配合你的应用和编程智能体一起工作。所有数据都留在你的电脑上。
+<p align="center"><sub><a href="README.md">English</a> · <b>简体中文</b> · <a href="README.ja.md">日本語</a> · <a href="README.de.md">Deutsch</a> · <a href="README.fr.md">Français</a> · <a href="README.es.md">Español</a> · <a href="README.pt-BR.md">Português</a> · <a href="README.pl.md">Polski</a></sub></p>

-## 速度有多快？
+**免费、开源，由你自己运行。** 在桌面上使用 Strata，或搭配你喜欢的编程工具。无需账号。

-我们在两台普通的游戏电脑上做了测试。一个 token 大约相当于 ¾ 个英文单词。
+## 模型

- **写回答：** 短对话中回复出现的速度。每秒 60 个 token 已经比你的阅读速度还快。
- **读提示：** 读入你发送内容的速度（这里是一份 32K token 的文档、代码或聊天记录）。
+我们**首先推荐 ISTA-DASLab**，其次是 **Unsloth** 和其他提供方，前提是有内存放得下的兼容模型。

-<table>
-<tr><th>NVIDIA：RTX 5070（12 GB）、Ryzen 5 7600、64 GB 内存</th><th>AMD：RX 9070 XT（16 GB）、Ryzen 9 3900X、47 GB 内存</th></tr>
-<tr><td>
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.8-Flash-Next</b></summary>

-| 规格 | 写回答 | 读提示 |
-| --- | ---: | ---: |
-| **Q2_0** | 94 tokens/s | 2,650 tokens/s |
-| **IQ2_XS** | 79 tokens/s | 2,090 tokens/s |
-| **IQ3_XXS** | 62 tokens/s | 1,750 tokens/s |
-| **IQ3_S** | 53 tokens/s | 1,620 tokens/s |
-| **Coder** | 55 tokens/s | 2,180 tokens/s |
-
-</td><td>
-
-| 规格 | 写回答 | 读提示 |
-| --- | ---: | ---: |
-| **Q2_0** | 60 tokens/s | 1,160 tokens/s |
-| **IQ2_XS** | 52 tokens/s | 1,110 tokens/s |
-| **Coder** | 44 tokens/s | 1,420 tokens/s |
-
-</td></tr>
-</table>
-
-NVIDIA：Q2_0 用的是引擎 0.1.36，其他各行用的是 0.1.26（4K 回答，32K 提示）。完整表格见
-[DETAILS.md](docs/DETAILS.md#speed-measured)。显存越大的显卡越快：RTX 3090（24 GB）写回答应该能达到每秒约
-100-140 个 token。长对话和其他显卡的数据：[各模型的速度](docs/MODELS.md#how-fast-is-each-size)、
-[社区测试结果](docs/COMMUNITY_BENCHMARKS.md)。
-
-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="请我喝杯咖啡" height="50"></a><br>
-<sub>Strata 是免费的。如果它在你的电脑上跑得不错，请我喝杯咖啡，让这个项目继续下去。</sub></p>
-
-## 你需要什么
-
-| | |
+| 提供方 | 可选项 |
 | --- | --- |
-| **显卡** | **NVIDIA** GeForce RTX 20、30、40 或 50 系列，或 **AMD** Radeon RX 7900 XT / XTX、RX 7800 XT / 7700 XT、RX 9060 XT、RX 9070 / 9070 XT、Radeon AI PRO R9700 或 RX 6800 / 6900 系列。需要 **12 GB 或以上显存**。 |
-| **内存** | 32 GB 或以上。内存大小决定能装下[哪个模型](#该选哪个模型)。64 GB 可以运行所有规格。 |
-| **硬盘** | 约 80 GB 可用空间。尽量用 SSD：第一次启动会快很多。 |
-| **系统** | Windows 10 / 11 或 Linux，以及 NVIDIA 或 AMD 的最新显卡驱动。 |
+| **ISTA-DASLab · 推荐** | Q2\_0, IQ2\_XS, IQ3\_XXS, IQ3\_S。[Coder：IQ1\_M](docs/MODELS.md#coder)，适合写代码。 |
+| **Unsloth** | UD-IQ4\_XS, UD-Q4\_K\_XL, UD-Q5\_K\_XL, UD-Q6\_K\_XL, Q8\_0 |
+| **Gyro · agentionai** | [Gyro-S, Gyro-M](https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-GGUF)。占用内存更少，但速度更慢。 |
+| **其他选项** | [Swift 1.5](docs/MODELS.md#swift-15), [NVFP4](docs/NVFP4.md), [OrcaRouter](docs/ORCA.md) |

-其他的都由安装程序搞定。两到三张显卡可以分担同一个模型（[多 GPU](docs/MULTI_GPU.md)）。
+[比较大小、内存需求和兼容性](docs/MODELS.md)。

-实验性支持，由社区成员在自己的机器上编写和测试：
+</details>

- **较老的显卡**（Tesla P40 / V100、GTX 10、Radeon VII / MI50、RX 6700 XT、RX 5500 XT）：[较老的 GPU](docs/OLDER_GPUS.md)。
- **Intel Arc**，在 Linux 上从源码构建：[Intel Arc](docs/INTEL_ARC.md)。
- **AMD Ryzen AI Max（Strix Halo）**，在 Linux 上从源码构建：[Strix Halo](docs/STRIX_HALO.md)。
- **不支持 AVX2 的老处理器**：能用，但很慢。[较老的 CPU](docs/INSTALL.md#older-cpus-experimental)。
+<details>
+<summary><img src="docs/media/models/qwen.svg" width="22" alt="" align="middle"> &nbsp;<b>Qwen3.6-35B-A3B</b></summary>

-完整列表：[docs/INSTALL.md](docs/INSTALL.md#what-you-need)。
+**Unsloth:** UD-Q4_K_XL, UD-Q6_K_XL, Q8_0。这些是目前文档中收录的该模型的版本。
+
+[模型指南和兼容性](docs/QWEN36.md)。
+
+</details>
+
+<details>
+<summary><img src="docs/media/models/deepseek.svg" width="22" alt="" align="middle"> &nbsp;<b>DeepSeekV4.1-Flash-1017</b></summary>
+
+可在**桌面应用**和**终端**中使用。内存放不下的部分会从 SSD 读取，所以需要大量空闲磁盘空间。
+
+| 版本（IST-DAS） | 下载大小 | 所需空闲磁盘 |
+| --- | ---: | ---: |
+| 1.75 bpw | 239 GB | 约245 GB |
+| 2.00 bpw | 257 GB | 约265 GB |
+| 2.25 bpw | 274 GB | 约280 GB |
+
+支持 NVIDIA RTX 30、40 和 50 系列（Windows 和 Linux），以及 AMD Radeon AI PRO R9700（Linux）。安装程序会下载模型文件和 DeepSeek 引擎，然后启动模型。
+
+```sh
+strata launch --family deepseek41 --model ist-das-2.00bpw --plan
+```
+
+以下为 Strata 0.2.5 上 2.00 bpw 版本的实测结果。“输出”是回答的速度，“提示词”是 Strata 读取你输入内容的速度。
+
+| 硬件 | 输出 | 提示词 |
+| --- | ---: | ---: |
+| RTX 5070 12 GB, 64 GB 内存 | 4 到 6 tokens/s | 约 110 tokens/s（4K） |
+| RTX 3060 12 GB, 46 GB 内存 | 9 到 11 tokens/s | 约 155 tokens/s（4K） |
+| 1x Radeon AI PRO R9700, 251 GB 内存 | 21 到 25 tokens/s | 320 到 360 tokens/s (8K) |
+| 4x Radeon AI PRO R9700 | 74 到 77 tokens/s | 400 到 450 tokens/s (8K) |
+
+[内存、磁盘和详细信息](docs/DEEPSEEK41.md) · [发行说明](https://github.com/Niko1221/Strata/releases)
+
+</details>
+
+<a id="the-other-sizes"></a>
+
+不确定哪个放得下？[为你的电脑选择模型](docs/MODELS.md#pick-by-memory)。

 ## 安装

-### 让你的 AI 帮你装
+<a id="option-a-the-strata-app"></a>

-你在用 AI 编程助手吗（Claude Code、Cursor、Codex、GitHub Copilot 等）？把下面这段粘贴给它：
+### 桌面应用

-```text
-Set up Strata on this PC for me: https://github.com/Niko1221/Strata - follow docs/AI_SETUP.md in that repository.
+**[下载适用于 Windows、Linux 或 Mac 的 Strata →](https://github.com/Niko1221/Strata/releases/latest)**
+
+安装应用，选择模型，就可以开始聊天。每个系统只有一个安装程序。首次启动时，应用会下载适合你显卡的引擎。[安装程序帮助](docs/INSTALL.md#the-app)。
+
+<sub>文件: `Strata-0.2.7-windows-x64-setup.exe` · `Strata-0.2.7-linux-x86_64.AppImage` · `Strata-0.2.7-macos-arm64.dmg`</sub>
+
+<p align="center">
+  <img src="docs/media/app-chat.png" width="900" alt="Strata 桌面应用，聊天和实时代码预览并排显示">
+  <br><sub>聊天、文件和实时预览都在一个窗口里。</sub>
+</p>
+
+<a id="option-b-the-terminal-one-line"></a>
+
+### 终端应用
+
+更喜欢终端？安装 Strata，然后运行 **`strata launch`**。
+
+<details open>
+<summary><b>安装命令</b></summary>
+
+**Linux / Mac**
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
 ```

-它会检查你的显卡、内存和硬盘，选出合适的模型。然后安装并启动它，再告诉你怎么连接你的应用。AI 工具也可以通过
-Strata 的 [MCP 服务器](docs/MCP_SERVER.md)来安装、启动和停止 Strata。
+**Windows PowerShell**

-### 或者自己动手
-
-[下载 Strata](https://github.com/Niko1221/Strata/archive/refs/heads/main.zip) 并解压（或者用 `git clone`）。
-**Windows：** 双击 **`START-HERE.bat`**。**Linux：** 在 Strata 文件夹里运行 **`./setup.sh`**。
-
-**Mac（Apple 芯片，M1 到 M5，macOS 15 或更新版本）：** 先安装一次 Apple 的 Command Line Tools（在终端里运行 `xcode-select --install`；不需要 Xcode 本身）。然后在 Strata 文件夹里打开终端，运行 **`./setup.sh`**。它会在你的 Mac 上编译 Mac 版引擎（大约 7 分钟），问同样的问题，下载模型并启动。下次运行 `./setup.sh` 会马上启动。哪个大小适合你的 Mac、速度如何：[docs/MAC.md](docs/MAC.md)。
-
-NVIDIA 和 AMD 的步骤完全一样。安装程序会识别你的显卡，并装好对应的引擎。它会问你几个问题：
-
- 用哪个模型、哪个规格，
- 上下文多大（模型能记住多少文字），
- 是否要识别图片。
-
-每次直接按回车就是推荐选项。之后它会下载模型（约 70 GB）并启动。如果下载中断了，再运行一次即可：它会从中断的地方继续。
-浏览器会打开 Strata 应用，地址是 `http://127.0.0.1:8080`。
-
-> **模型启动时，你的电脑可能会变慢或卡住 1-3 分钟**（第一次最久）。
-> Strata 会把 35-55 GB 加载到内存，并为显卡锁定其中一部分。这是正常的。请耐心等待，不要关闭窗口。
-> 窗口里会显示 Strata 正在做什么。
-
-**下次使用时**，再运行一次 `START-HERE.bat`（或 `./setup.sh`）。它会马上启动，已下载的东西不会重复下载。关闭它的窗口就能停止模型。
-`UPDATE.bat`（`./update.sh`）只更新 Strata，不启动。更新、Docker、多张显卡、文件存放位置以及所有选项：
-[docs/INSTALL.md](docs/INSTALL.md)。
-
-## 该选哪个模型
-
-安装程序会根据你的内存推荐一个。同一个模型有几种规格，压缩程度不同。规格越小越快，越大越聪明一些。
-
-| 你的内存 | 选择 | 原因 |
-| --- | --- | --- |
-| **32 GB** | **Coder** | 32 GB 装得下，而且专为代码打造（如果显卡是 24 GB，Q2_0 和 IQ2_XS 也能跑） |
-| **48 GB** | **IQ2_XS**（或 Q2_0，最快） | 更大的规格装不下 |
-| **64 GB** | **IQ2_XS**（推荐），或 IQ3_XXS / IQ3_S | 所有规格都装得下；IQ3_S 最好，也最慢 |
-| **96 GB 或以上** | **IQ3_S**，或 Unsloth 的 UD-IQ4_XS（约 4-bit） | 开着其他程序也能放下最大的规格 |
-
- **[Coder](docs/MODELS.md#coder)：** 编程版本，去掉了一半专家。它达到完整模型 SWE-bench Verified 分数的 91%（由其作者测得），
-  32 GB 内存就能装下。代码以外的能力较弱，包括中文和其他中日韩文本（#438）。这类用途请选 Q2_0、IQ2_XS 或 IQ3_S，
-  它们保留了所有专家。
- **[Swift 1.5](docs/MODELS.md#swift-15)：** 一个微调版本，回答前思考的时间短得多。你能更早拿到答案，质量基本不变。
- **[Unsloth UD-IQ4_XS](docs/MODELS.md#unsloth-ud-iq4_xs)：** Unsloth 的约 4-bit 版本，质量介于 IQ3_S 和 UD-Q4_K_XL 之间。
-  下载 94 GB。内存少于约 80 GB 时，Strata 回答时要从 SSD 读取其中一部分，所以会更慢（NVMe SSD 有帮助）。
- **[Unsloth UD-Q4_K_XL、UD-Q5_K_XL、UD-Q6_K_XL 和 Q8_0](docs/MODELS.md#unsloths-files-ud-iq4_xs-to-q8_0)：** 4 到 8 位，更接近完整模型（下一个 token
-  与 Q8_0 相同的比例为 93-95%）。所有专家都能放进内存时速度很快（UD-Q4_K_XL 约需 88 GB，Q8_0 约需 136 GB）；内存不够时，
-  Strata 回答时要从 SSD 读取一部分，会慢很多（64 GB 的电脑上 UD-Q4_K_XL 每秒 7-8.5 个 token）。
- **[OrcaRouter 的 Uncensored IQ3_XXS](docs/MODELS.md#orcarouter-uncensored-iq3_xxs)：** 需要手动设置，不在安装程序的菜单里。
-
-规格、下载以及各配置能装下什么：[docs/MODELS.md](docs/MODELS.md)。以后想再添加模型，运行
-`SETUP.bat`（Linux：`./setup.sh --setup`）。
-
-## 使用方法
-
-<p align="center"><img src="docs/media/runpagoda.png" width="900" alt="Strata 应用的 Monitor 标签页，旁边是一个编程智能体"><br>
-<sub>Strata 应用的 <b>Monitor</b>（左），编程智能体正在写视频里的宝塔花园（右）</sub></p>
-
- **在浏览器里：** 打开 `http://127.0.0.1:8080`。里面有 **Chat**（聊天）、实时 **Monitor**（监控模型和你的
-  GPU/CPU/内存），以及 **About**（设置和地址）。
- **你的应用和编程智能体：** 添加一个“OpenAI 兼容”的提供商，base URL 填 **`http://127.0.0.1:8080/v1`**。
-  API key 和模型名随便填都行。
-  - 使用 Anthropic API 的应用：`http://127.0.0.1:8080/v1/messages`（Claude Code：
-    `ANTHROPIC_BASE_URL=http://127.0.0.1:8080`）。
-  - Codex CLI 和其他使用 OpenAI Responses API 的应用：`/v1/responses`
-    （[设置方法](docs/DETAILS.md#the-responses-api-and-codex-cli)）。
- **思考：** 在聊天菜单或应用的“reasoning effort”里选择 **off、low、medium 或 high**。off 最快，
-  high 最适合难题。
- **图片：** 在安装时对“Images?”选是。然后在聊天里点 **Picture**，或在你的应用里附上图片。
-  AMD 显卡在 Linux 上通过处理器识别图片；在 Windows 上暂时还不行。
- **从手机或另一台电脑访问：** `START-HERE.bat --setup --host 0.0.0.0 --api-key <secret>`。一定要设置 key。
- **一次处理一个请求：** 默认情况下 Strata 一次只回答一个请求，其他请求排队等待。想同时回答多个，
-  设置 `"parallel": 2`（[BATCHING.md](docs/BATCHING.md)）。在 12 GB 显卡上，这会让每个回答变慢。
- **长提示：** Strata 会完整读入对话的第一条消息，大约每 30,000 个 token 需要 1 分钟。之后的消息几秒内就开始回答。
-
-更多：[聊天记录存在哪里](docs/INSTALL.md#where-things-are-stored)、[API](docs/DETAILS.md#using-it)。
-
-### 可选：整个模型都能放进内存时，单卡再提速
-
-两个可选设置（来自 RubenTorney 的 #1904 和 #1905）。适用于只用一张显卡、并且内存能放下所有专家的情况（Strata 的 arena 模式，例如 64 GB 电脑上的 Q2_0 或 IQ3_XXS）。打开 Strata 数据文件夹里的配置文件 `strata-<model>.json`（[在哪里](docs/INSTALL.md#where-things-are-stored)），加入：
-
- **生成更快：** 在 `"args"` 列表里加 `"--adapt-async", "1"`。专家缓存改在辅助线程里更新，不再暂停回答。在 RTX 5070（Windows，Q2_0）上实测：生成 +4-5%，代码和长文档 +7-10%。回答可能与默认设置略有不同（但每次运行都一样）。
- **Windows 上读取提示更快：** 在 `"env"` 块里加 `"STRATA_PIN_BY_NEED": "1"`。Windows 只能为显卡锁定大约一半的内存；这个设置会先锁定显卡真正需要的专家。在 RTX 5070 上实测：读取提示 +4.4%。
-
-```json
-"args": [ ..., "--adapt-async", "1" ],
-"env": { "STRATA_PIN_BY_NEED": "1" }
+```powershell
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
 ```

-修改后重启 Strata（`START-HERE.bat` 或 `./setup.sh`）。要撤销，删掉这两项即可。
+在 Windows 上，安装后请打开一个新的终端。然后运行：

-## 出问题了？
+```sh
+strata launch
+```

- **Strata 第一次启动时电脑卡死了。** 加载模型时这是正常的。请耐心等待，不要关闭窗口。
-  10 分钟后还卡着？重启电脑，关掉其他程序再试一次，或者换一个更小的规格。
- **下载或安装时中断了。** 再运行一次 `START-HERE.bat`（或 `./setup.sh`）。它会从中断的地方继续。
- **非常慢，硬盘灯一直闪，或者提示“the engine stopped unexpectedly”。** 你的电脑可用内存不够。
-  关掉其他程序（浏览器很占内存），或者换一个更小的规格（Q2_0 或 IQ2_XS）。
- **提示 8080 端口已被占用。** Strata 已经在运行了。找一下它的窗口。
+按提示下载并启动模型。[终端指南](docs/TERMINAL_LAUNCH.md)。

-更多问题和解决办法：[docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md)。还是解决不了？提交一个
-[issue](https://github.com/Niko1221/Strata/issues)，并附上 Strata 文件夹里的 `strata-<model>.log`。发现了安全问题？
-请私下报告：[SECURITY.md](SECURITY.md)。
+</details>

-## 它是怎么工作的？
+<p align="center">
+  <img src="docs/media/terminal-monitor.png" width="900" alt="Strata 终端应用，显示模型活动、速度、内存和最近的请求">
+  <br><sub>模型运行时，随时查看模型和硬件状态。</sub>
+</p>

-这类模型通常运行在拥有数百 GB 显存的服务器上。而你的显卡只有 12-24 GB。Strata 让模型装得下的办法是
-**把工作分摊到整台电脑上**。可以想象一个厨房：常用的东西放在台面上，其余的放在储藏室里。
+<a id="build-from-source"></a>

-<p align="center"><img src="docs/media/how-it-works.svg" width="860" alt="模型的 24,576 个专家：最常用的在显卡上，全部在内存里，一张查找表在 SSD 上"></p>
+[从源码构建](docs/SOURCE_INSTALL.md) · [Docker](docs/DOCKER.md) · [完整安装指南](docs/INSTALL.md)

- **这个模型是由 24,576 个小专家（“experts”）组成的团队。** 每个词只需要其中 10 个。
- **你的显卡** 存放最常用的几千个专家。**你的内存** 存放全部专家，
-  **你的处理器** 同时处理其余的部分。**你的 SSD** 存放一张大查找表。
+<a id="what-you-need"></a>

-<p align="center"><img src="docs/media/guess-and-check.svg" width="860" alt="一个小助手猜测接下来的几个词；大模型一次性全部检查，保留正确的"></p>
+## 硬件

- **先猜，再检查：** 一个小助手先猜接下来的几个词，大模型再一次性检查它们。答案完全一样，但快 1.6-1.8 倍。
- **长文本分大块读入**（每次最多 8,192 个 token），速度超过每秒 1,000 个 token。
+| 支持的硬件 | 指南 |
+| --- | --- |
+| **NVIDIA GeForce RTX 20 / 30 / 40 / 50 系列** | [NVIDIA 安装](docs/INSTALL.md#what-you-need) |
+| **AMD Radeon RX 7700 / 7800 / 7900、RX 9060 / 9070、AI PRO R9700** | [AMD 安装](docs/AMD_HIP.md) |
+| **AMD Radeon RX 6800 / 6900 · 实验性** | [RX 6000 安装](docs/AMD_HIP.md#rdna2-gfx1030) |
+| **Intel Arc · Linux** | [Intel 安装](docs/INTEL_ARC.md) |
+| **Apple Silicon · M1 或更新** | [Mac 安装](docs/MAC.md) |
+| **AMD Ryzen AI Max · Strix Halo** | [Strix Halo 安装](docs/STRIX_HALO.md) |

-更详细的解释：[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md)。每个部分及其数据：
-[详细说明](docs/DETAILS.md#how-it-works)和[论文](docs/paper/Strata-Paper.pdf)。
+<a id="using-it"></a>

-## 致谢与许可证
+## 工具

-模型是 Qwen 团队的 [Qwen3.8-Flash-Next](https://huggingface.co/Qwen/Qwen3.8-Flash-Next)。它由
-[ISTA-DASLab](https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-GGUF)、UkisAI（Swift 1.5）
-和 Unsloth 压缩。Strata 使用了 [llama.cpp / ggml](https://github.com/ggml-org/llama.cpp) 的部分代码。完整致谢：
-[docs/HOW_IT_WORKS.md](docs/HOW_IT_WORKS.md#credits)。Strata 以 [MIT 许可证](LICENSE)开源。少数部分和每个模型
-有各自的许可证（[具体是哪些](docs/HOW_IT_WORKS.md#license)）。
+**Claude Code · Codex CLI · OpenCode · oh-my-pi · pi.dev · Hermes Agent · OpenClaw**，也可以通过兼容 OpenAI 和 Anthropic 的 API 使用更多工具。
+
+运行 **`strata connect`**，查看你所用工具的设置方法。[连接指南](docs/TERMINAL_LAUNCH.md#connect-your-apps-strata-connect)。
+
+<a id="guides"></a>
+<a id="how-fast-is-it"></a>
+<a id="how-does-it-work"></a>
+<a id="something-went-wrong"></a>
+
+## 帮助
+
+[全部指南](docs) · [故障排查](docs/TROUBLESHOOTING.md) · [报告问题](https://github.com/Niko1221/Strata/issues/new/choose) ·
+[基准测试](docs/COMMUNITY_BENCHMARKS.md) · [工作原理](docs/HOW_IT_WORKS.md) · [参与贡献](CONTRIBUTING.md)

 ## 支持 Strata

-Strata 免费且开源。如果它对你有用，欢迎支持它的开发：
+**帮助本地 AI 保持开放。** 一杯咖啡能帮助我们在更多硬件上开发和测试。

-<p align="center"><a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="请我喝杯咖啡" height="50"></a></p>
+<a href="https://buymeacoffee.com/strataengine"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me a Coffee：支持 Strata" height="48"></a>
+
+[MIT 许可证](LICENSE) · [致谢和模型许可证](docs/HOW_IT_WORKS.md#credits) · [隐私](docs/SAFETY.md)
+
+<a id="option-c-let-your-ai-set-it-up"></a>
+
+<sub>面向 AI 工具和自动阅读器： <a href="AGENTS.md">技术参考</a> · <a href="docs/AI_SETUP.md">安装说明</a></sub>
+
+**赞助、硬件合作或其他合作：** [[email protected]](mailto:[email protected]).
@@ -23,8 +23,9 @@ this PC only. The details and every setting are in [docs/DETAILS.md](docs/DETAIL
 - **Where it listens.** `127.0.0.1` by default. `--host 0.0.0.0` (or `"host"` in `strata-<model>.json`) opens it to
  your network, and the server then warns when no API key is set.
 - **API key.** `"api_key"` in the run config (or `STRATA_API_KEY`) is required on `/v1/*` and on every endpoint
-  that shows the model's state, requests or answers (`/status`, `/metrics`, `/settings`, `/mcp`, `/props`, `/slots`,
-  `/api/requests`, `/config`) and on every `POST`. It is compared in constant time. Set one before you open the
+  that shows the model's state, requests or answers (`/status`, `/metrics`, `/metrics/prometheus`, `/settings`,
+  `/mcp`, `/props`, `/slots`, `/api/requests`, `/config`) and on every `POST`. It is compared in constant time.
+  Set one before you open the
  server to your network or put a tunnel in front of it.
 - **Host check (DNS rebinding, 0.1.38).** Without an API key the server answers only requests whose `Host` is a name
  it knows (`localhost`, an IP address, the address it listens on and, when it listens beyond this PC, this PC's
@@ -43,4 +44,53 @@ this PC only. The details and every setting are in [docs/DETAILS.md](docs/DETAIL
  last few prompts, whatever `"api_monitor"` says, to encode the next turn faster; no endpoint shows them, and they
  are gone when the server stops.

+## The desktop app and the Terminal
+
+Strata comes in three parts that share one engine: the **desktop app**, the **Terminal** (`strata`) and the **engine** that runs
+the model. The section above is about the engine's HTTP server. This is what the other two add.
+
+- **The app's host listens on this PC only.** The app serves its page from a local host process on `127.0.0.1` (port 8791 unless
+  changed). A request to its `/api/` endpoints that carries a browser `Origin` from any other site gets 403. The app shell holds a
+  random secret (32 characters or more, compared in constant time) that is needed to quit the host or tell it which window is open,
+  and the host gives its own helper processes a second random secret. By default the models the app starts are served on this PC only.
+- **Sharing is a separate, key-protected listener.** "Share with other devices" (and the Cloudflare tunnel) will not start until an
+  API key is set. It opens a different listener that answers only `/v1/models`, `/v1/chat/completions` and `/v1/messages`, never the
+  app's page or its host endpoints.
+- **App and Terminal talk through an owner channel.** One owner process per installation starts and ends the engine, and a second
+  client (the Terminal) attaches to it. On macOS and Linux that is a private Unix socket in a folder only you can open. On Windows it
+  is a TCP listener on `127.0.0.1` that answers only requests carrying a 256-bit token kept in an owner-only folder. That is a weaker
+  guarantee than a socket other users cannot open: on Windows the token is what protects it, as with any loopback service that has a
+  token (`strata_control/owner_transport.py`). The bridge between the app shell and the host (used for the app update) is also loopback and protected by a token.
+- **Starting a model and serving never download anything.** Downloads and updates are one explicit step: `strata update`, or "Update
+  engine" and "Update Strata" in the app's Settings. Models and saved tuning are never replaced by an update.
+- **Updates come from a signed feed.** The release publishes `strata-feed.json` and `strata-feed.json.sig` (Ed25519). An installed
+  Strata checks the signature against the public key it carries (`strata_control/update_keys.json`), refuses a feed older than the last
+  one it accepted (a replayed old feed) or expired, and checks every engine package against its SHA-256, its signed manifest and the
+  card in your PC before it test-starts it and switches to it. Any failure keeps the engine you had. The app installer itself is signed
+  with a separate key (Tauri's minisign key) that the app and the Terminal both check. The private keys are kept offline by the owner.
+  See [packaging/UPDATES.md](packaging/UPDATES.md).
+
+### How far to trust `curl | sh` and `irm | iex`
+
+The Terminal installs with one line:
+
+```sh
+curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
+irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
+```
+
+Piping a script into a shell runs whatever the server sends, so it deserves the same care as running any downloaded program.
+What the script does is short and written at its top: it fetches the Terminal archive named in the release's `install-manifest.txt`,
+checks its SHA-256, unpacks it into your home folder (no administrator rights, nothing outside your home), checks the release's signed feed
+with the Terminal it just unpacked and removes it again if that fails, and puts `strata` on your PATH.
+
+Those checks have a limit. The checksum comes from the same release as the archive, and the public key that checks the feed arrives inside
+that archive, so for the first install all trust rests on HTTPS and on the `Niko1221/Strata` GitHub release itself. The checks catch a
+damaged or half-finished download and a feed that was not signed by the release key; they do not protect you if the release has been replaced
+by someone who controls it. Later updates are checked against the key already on your PC, which is a stronger position.
+
+If that is not enough: save the script (`curl -fsSLO https://github.com/Niko1221/Strata/releases/latest/download/install.sh`), read it, and
+run it from the file; or install the desktop app or build from source instead and check the code you build.
+
 Strata has not had an outside security audit yet.
+What Strata downloads, when it uses the internet, what stays on your PC and how downloads are checked is written up in [docs/SAFETY.md](docs/SAFETY.md).
@@ -2,8 +2,13 @@
 rem Strata for Windows: the first run installs everything and starts the model; later runs just start it.
 rem Needs only an NVIDIA or AMD graphics driver. Python is installed for your user account if it is missing (no admin needed).
 setlocal
+rem Python reads and writes text as UTF-8, not in the Windows code page (cp1251, cp866, ...): a folder or user name with Cyrillic or other letters stays intact (#3202).
+set "PYTHONUTF8=1"
 title Strata
 cd /d "%~dp0"
+rem A bundled Python runtime (the python\ folder of the terminal archive) is used when it is there: nothing to find,
+rem install or download. SETUP.bat and UPDATE.bat run this file, so they use it too.
+if exist "python\python.exe" goto bundled
 if exist ".venv\Scripts\python.exe" goto run

 call :findpy
@@ -36,6 +41,14 @@ echo  Could not create the Python environment in .venv
 pause
 exit /b 1

+:bundled
+set "PYTHONNOUSERSITE=1"
+set "PYTHONHOME="
+set "PYTHONPATH="
+"python\python.exe" setup.py %*
+if errorlevel 1 pause
+exit /b
+
 :run
 ".venv\Scripts\python.exe" setup.py %*
 if errorlevel 1 pause
@@ -2,7 +2,8 @@
 rem Update Strata without starting the model (#475): the newest code (git pull, when this folder is a git clone), then
 rem what START-HERE.bat does before a start - the engine (a new one when this version needs it), the Python packages,
 rem each installed model's settings and draft subset. The model files are not touched. Start the model later with
-rem START-HERE.bat. Options are passed on to setup.py.
+rem START-HERE.bat. Options are passed on to setup.py. The bundled Python (python\ beside this file) is used when
+rem there is one: START-HERE.bat, which this file runs, picks it.
 setlocal
 title Strata - update
 cd /d "%~dp0"
@@ -0,0 +1,232 @@
+{
+  "name": "strata-desktop",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "strata-desktop",
+      "version": "0.1.0",
+      "devDependencies": {
+        "@tauri-apps/cli": "2.12.3"
+      }
+    },
+    "node_modules/@tauri-apps/cli": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli/-/cli-2.12.3.tgz",
+      "integrity": "sha512-f7/LsY74SVb1ChmOPw1ajOpxii0GSzDAgmWHRci8JUYuuai04rXsSbFobpmB0sP2DdlvMD/B5ZotEn8GOGMRUg==",
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "bin": {
+        "tauri": "tauri.js"
+      },
+      "engines": {
+        "node": ">= 10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/tauri"
+      },
+      "optionalDependencies": {
+        "@tauri-apps/cli-darwin-arm64": "2.12.3",
+        "@tauri-apps/cli-darwin-x64": "2.12.3",
+        "@tauri-apps/cli-linux-arm-gnueabihf": "2.12.3",
+        "@tauri-apps/cli-linux-arm64-gnu": "2.12.3",
+        "@tauri-apps/cli-linux-arm64-musl": "2.12.3",
+        "@tauri-apps/cli-linux-riscv64-gnu": "2.12.3",
+        "@tauri-apps/cli-linux-x64-gnu": "2.12.3",
+        "@tauri-apps/cli-linux-x64-musl": "2.12.3",
+        "@tauri-apps/cli-win32-arm64-msvc": "2.12.3",
+        "@tauri-apps/cli-win32-ia32-msvc": "2.12.3",
+        "@tauri-apps/cli-win32-x64-msvc": "2.12.3"
+      }
+    },
+    "node_modules/@tauri-apps/cli-darwin-arm64": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-darwin-arm64/-/cli-darwin-arm64-2.12.3.tgz",
+      "integrity": "sha512-xmVNoJOOKzKLj7GLHXmXLimRby9M42aBIJa0sB80N7o24eKV5JiVmToKTRLVH9yhL05GZ/B6rSSOmbzNFJwBAA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-darwin-x64": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-darwin-x64/-/cli-darwin-x64-2.12.3.tgz",
+      "integrity": "sha512-URd+0usfmUQQyb5kNPiKt2OT8gp7oGU7QR+qOppB6e35mpVBFFVNhWc9oWb3p0u71fDJ09DpF4T6m9xYxoIB8g==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm-gnueabihf": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm-gnueabihf/-/cli-linux-arm-gnueabihf-2.12.3.tgz",
+      "integrity": "sha512-0kwUVx2LbmOoTRlwF1oDww7th4/NSluv4ZBQ6KRZsFKg4g0TlTcIiJ0VehqkQYUeC9xIT1Mk6XtF52mI155VSQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm64-gnu": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-gnu/-/cli-linux-arm64-gnu-2.12.3.tgz",
+      "integrity": "sha512-gKSGDx6fx+HBLQmG6guChFdisbrCSdx9Yli+j5teOa64gm1CeM+C6NLru5Pj3ZkkEep05BmCFjxvX+cjqAycZQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-arm64-musl": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-arm64-musl/-/cli-linux-arm64-musl-2.12.3.tgz",
+      "integrity": "sha512-Yr59qMy/gcvAfBuFdCGlAmGiLsYWMFDbsP4bAI6iNBzcJTGrYWZGeiQhGDo29MQwfF/NUBqyM2qljXu5tZ6wjQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-riscv64-gnu": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-riscv64-gnu/-/cli-linux-riscv64-gnu-2.12.3.tgz",
+      "integrity": "sha512-jKr0/REBMnLKC0OwPQZkyge0mKDaNZ0b/AbfGwVyCgFfwS730EVLfVDo3nt7MUu6jJaytRq08+xSj5qfy+U1+Q==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-x64-gnu": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-gnu/-/cli-linux-x64-gnu-2.12.3.tgz",
+      "integrity": "sha512-gTkEqJAGCMROGanxHnzaJzQ+/rXl39HWVg0/hDODS1wDWBGqoceqGC6Qm1+mQbyT11xnsB8mKu/gyVID/YpFIw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-linux-x64-musl": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-linux-x64-musl/-/cli-linux-x64-musl-2.12.3.tgz",
+      "integrity": "sha512-T2dTxL1svRym71fZtaW4pZYXbthbfFsEJr1NeOUg/p7laWXZbUt/8DMSZf8recu9f7+1F/Lv00HtzsEu6vDO9w==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-arm64-msvc": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-arm64-msvc/-/cli-win32-arm64-msvc-2.12.3.tgz",
+      "integrity": "sha512-eoiQwpEZWbpsVHcM9BAzqqe4TCHszvr3rsM7pUQ4ofLK0lF1i1d/jX0Qo5DYMqcrUtwQuDdDuOCbcT0Izf1VwQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-ia32-msvc": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-ia32-msvc/-/cli-win32-ia32-msvc-2.12.3.tgz",
+      "integrity": "sha512-kE+KUg6Dbbkgvcw0m99wJVIToFQzJqpMBAXah74WqxaLzssNwSTUccrHp6+QVzMhjQP330tvekFmnQF+0NbE6Q==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    },
+    "node_modules/@tauri-apps/cli-win32-x64-msvc": {
+      "version": "2.12.3",
+      "resolved": "https://registry.npmjs.org/@tauri-apps/cli-win32-x64-msvc/-/cli-win32-x64-msvc-2.12.3.tgz",
+      "integrity": "sha512-L7wndWAgX2mLW7alswpL3d1R0P9FN2WYBgHaQkAYEBxHHGkY4vFX9CjcRQ1LAxDAMIJxrY7/aDziFJeChS84NQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 OR MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">= 10"
+      }
+    }
+  }
+}
@@ -0,0 +1,20 @@
+{
+  "name": "strata-desktop",
+  "productName": "Strata",
+  "version": "0.2.7",
+  "private": true,
+  "description": "Strata Desktop - local AI, tuned to one model.",
+  "scripts": {
+    "build:ui": "npm --prefix ../host run build",
+    "typecheck:ui": "npm --prefix ../host run typecheck",
+    "test:ui": "npm --prefix ../host test",
+    "tauri": "tauri",
+    "dev": "npm run build:ui && tauri dev",
+    "build": "npm run build:ui && tauri build",
+    "build:app": "npm run build:ui && tauri build --bundles app",
+    "dmg": "npm run build:ui && tauri build --bundles dmg"
+  },
+  "devDependencies": {
+    "@tauri-apps/cli": "2.12.3"
+  }
+}
@@ -0,0 +1,361 @@
+#!/usr/bin/env python3
+"""The installed Windows app, closed every way, with a stub engine: nothing may be left running.
+
+    python apps/desktop/scripts/app-close-matrix.py --install <folder the installer wrote> [--scenarios all] [--report out.json]
+
+For each case it starts the REAL installed `strata-desktop.exe` (its window opens), loads a stub engine through the host's API
+(profile + `runtime start` under Control's owner runtime, exactly the app's path), records every process of the tree (the app,
+the host, Control, the owner host, the server, the engine), ends the app one way, and asserts:
+  * no process of the tree is left, the engine's port is free, the runtime lease can be taken again;
+  * the engine got the clean stop where the way of closing allows one (normal close, window X);
+  * the next load of the same slot works (a lost owner's state is cleaned, not a blocker).
+It also proves a second launch focuses the open window and starts nothing, and that one app runs two engines and closes both.
+Everything per-user lives under a scratch folder; the stub engine is a script. No real engine ever runs.
+"""
+from __future__ import annotations
+
+import argparse
+import ctypes
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import urllib.error
+import urllib.request
+from ctypes import wintypes
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[3]
+sys.path.insert(0, str(ROOT))
+
+import psutil  # noqa: E402
+
+from strata_control import procs, runtime  # noqa: E402
+from tests.terminal.lifecycle_matrix import install_fake_engine, port_open  # noqa: E402
+
+if os.name != "nt":
+    raise SystemExit("this matrix drives the Windows installer's app")
+
+user32 = ctypes.WinDLL("user32", use_last_error=True)
+WM_CLOSE = 0x0010
+
+
+def main_window(pid: int) -> int | None:
+    found = []
+
+    @ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
+    def visit(hwnd, _):
+        owner = wintypes.DWORD()
+        user32.GetWindowThreadProcessId(hwnd, ctypes.byref(owner))
+        if owner.value == pid and user32.IsWindowVisible(hwnd):
+            buf = ctypes.create_unicode_buffer(256)
+            user32.GetWindowTextW(hwnd, buf, 256)
+            if buf.value.strip() == "Strata":
+                found.append(hwnd)
+        return True
+    user32.EnumWindows(visit, 0)
+    return found[0] if found else None
+
+
+class Scratch:
+    def __init__(self, root: Path, install: Path):
+        self.root, self.install = root, install
+        self.components = root / "components"
+        self.models = root / "models"
+        self.mark = root / "mark"
+        for d in (self.components, self.models, self.mark, root / "local", root / "home", root / "appdata", root / "webview"):
+            d.mkdir(parents=True, exist_ok=True)
+        install_fake_engine(self.components)
+        from tools.strata_tokenizer import BYTE_TO_UNICODE
+        tok = self.models / "tokenizer"
+        tok.mkdir()
+        tokens = [BYTE_TO_UNICODE[i] for i in range(256)] + ["ab", "<|im_start|>", "<|im_end|>", "<|endoftext|>"]
+        (tok / "vocab.json").write_text(json.dumps({t: i for i, t in enumerate(tokens)}))
+        (tok / "merges.txt").write_text("a b")
+        (tok / "token_type.json").write_text(json.dumps([0] * 257 + [3, 3, 3]))
+        for name in ("stub", "stub2"):
+            (self.models / f"strata-{name}.json").write_text(json.dumps({
+                "exe": "component:strata-engine", "backend": "cuda", "tokenizer": str(tok), "args": [], "cwd": str(root),
+                "model_name": name, "host": "127.0.0.1", "port": 0}))
+        self.env = {**os.environ, "STRATA_COMPONENTS_DIR": str(self.components), "STRATA_PROFILE_DIR": str(root / "profiles"),
+                    "STRATA_RUNTIME_DIR": str(root / "runtime"), "STRATA_INSTALL_DIR": str(self.models),
+                    "STRATA_MODELS_DIR": str(root / "models-unused"), "STRATA_ENGINE_BACKEND": "cuda",
+                    "STRATA_HOME": str(root / "home"), "APPDATA": str(root / "appdata"), "LOCALAPPDATA": str(root / "local"),
+                    "WEBVIEW2_USER_DATA_FOLDER": str(root / "webview"), "FAKE_ENGINE_MARK": str(self.mark),
+                    "FAKE_ENGINE_SLOW_STEPS": "0", "PYTHONDONTWRITEBYTECODE": "1"}
+        self.env.pop("STRATA_API_KEY", None)
+        for key in ("STRATA_COMPONENTS_DIR", "STRATA_PROFILE_DIR", "STRATA_RUNTIME_DIR", "LOCALAPPDATA", "STRATA_ENGINE_BACKEND",
+                    "STRATA_NO_ACQUIRE", "FAKE_ENGINE_MARK"):
+            os.environ[key] = self.env.get(key, "1")          # this process reads the same runtime and records folders
+
+
+class App:
+    def __init__(self, scratch: Scratch):
+        self.s = scratch
+        self.proc = subprocess.Popen([str(scratch.install / "strata-desktop.exe")], cwd=scratch.install, env=scratch.env,
+                                     stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        self.base = None
+
+    def host(self):
+        for child in psutil.Process(self.proc.pid).children(recursive=True):
+            if child.name().lower() == "node.exe":
+                return child
+        return None
+
+    def wait_up(self, seconds=90):
+        deadline = time.monotonic() + seconds
+        while time.monotonic() < deadline:
+            if self.proc.poll() is not None:
+                raise RuntimeError(f"the app exited with {self.proc.returncode}")
+            try:
+                host = self.host()
+                if host:
+                    for c in host.net_connections(kind="tcp"):
+                        if c.status == "LISTEN" and c.laddr.ip == "127.0.0.1":
+                            base = f"http://127.0.0.1:{c.laddr.port}"
+                            try:
+                                if urllib.request.urlopen(base + "/api/health", timeout=2).status == 200 and main_window(self.proc.pid):
+                                    self.base = base
+                                    return
+                            except OSError:
+                                pass
+            except psutil.Error:
+                pass
+            time.sleep(0.5)
+        raise RuntimeError("the app did not come up")
+
+    def call(self, path, method="GET", body=None):
+        req = urllib.request.Request(self.base + path, method=method, data=None if body is None else json.dumps(body).encode(),
+                                     headers={"content-type": "application/json"})
+        try:
+            with urllib.request.urlopen(req, timeout=120) as r:
+                return json.loads(r.read() or b"null")
+        except urllib.error.HTTPError as exc:
+            raise RuntimeError(f"{method} {path} -> {exc.code} {exc.read()[:300]!r}") from None
+
+    def load(self, model, multiple=False):
+        self.call("/api/native?refresh=1")
+        started = self.call("/api/native/operations", "POST", {"kind": "load", "args": {"model": model, **({"multiple": True} if multiple else {})}})
+        deadline = time.monotonic() + 180
+        while time.monotonic() < deadline:
+            state = self.call("/api/native")
+            job = next((j for j in state["jobs"] if j["id"] == started["id"]), None)
+            if job and job["state"] != "running":
+                if job["state"] != "done":
+                    raise RuntimeError(f"load {model}: {job['state']} {job.get('error')}")
+                return state
+            time.sleep(0.3)
+        raise RuntimeError("load did not finish")
+
+
+def tree_of(app: App, slots=("app-1",)) -> tuple[list[procs.Ident], list[int]]:
+    idents, ports = [], []
+    members = [psutil.Process(app.proc.pid), *psutil.Process(app.proc.pid).children(recursive=True)]
+    pids = {p.pid for p in members}
+    for slot in slots:
+        state = runtime._read_state(slot)
+        if state:
+            pids.add(state["host_pid"])
+    for r in procs.records():
+        if r.get("profile") in slots:                 # the app's own slots; a Terminal service is not part of the app's tree
+            pids.add(r["pid"])
+    for pid in pids:
+        token = procs.start_token(pid)
+        if token:
+            idents.append(procs.Ident(pid, token, tuple(procs.command_line(pid) or [])))
+    return idents, ports
+
+
+def survivors(idents):
+    return [f"{i.pid} {' '.join(i.cmd)[:80]}" for i in idents if procs.start_token(i.pid) == i.token]
+
+
+def wait_gone(idents, seconds):
+    deadline = time.monotonic() + seconds
+    left = survivors(idents)
+    while left and time.monotonic() < deadline:
+        time.sleep(0.25)
+        left = survivors(idents)
+    return left
+
+
+def lease_free() -> bool:
+    try:
+        fd = runtime.acquire_activity_lease(shared=False)
+    except Exception:  # noqa: BLE001
+        return False
+    runtime._unlock_file(fd)
+    os.close(fd)
+    return True
+
+
+def control(scratch: Scratch, *argv: str, timeout: int = 300) -> dict:
+    py = scratch.install / "control" / "python" / "python.exe"
+    out = subprocess.run([str(py), str(scratch.install / "control" / "strata.py"), *argv, "--output", "json"],
+                         env={**scratch.env, "PYTHONNOUSERSITE": "1", "STRATA_NO_ACQUIRE": "1"},
+                         capture_output=True, text=True, timeout=timeout)
+    try:
+        return json.loads(out.stdout)
+    except ValueError:
+        return {"ok": False, "raw": out.stdout[-300:] + out.stderr[-300:]}
+
+
+def stop_cli(scratch: Scratch, slot: str) -> dict:
+    py = scratch.install / "control" / "python" / "python.exe"
+    out = subprocess.run([str(py), str(scratch.install / "control" / "strata.py"), "runtime", "stop", "--profile", slot, "--wait", "30",
+                          "--output", "json"], env={**scratch.env, "PYTHONNOUSERSITE": "1", "STRATA_NO_ACQUIRE": "1"},
+                         capture_output=True, text=True, timeout=120)
+    try:
+        return json.loads(out.stdout)
+    except ValueError:
+        return {"state": "?", "raw": out.stdout[-200:] + out.stderr[-200:]}
+
+
+def case(name: str, install: Path, how: str) -> dict:
+    with tempfile.TemporaryDirectory(prefix="strata-app-matrix-", ignore_cleanup_errors=True) as tmp:
+        saved = dict(os.environ)
+        scratch = Scratch(Path(tmp), install)
+        app = App(scratch)
+        problems, note = [], ""
+        try:
+            app.wait_up()
+            slots = ("app-1", "app-2") if how == "two-engines" else ("app-1",)
+            terminal = None
+            if how == "window-x-terminal-engine":
+                # an engine the Terminal started (its own profile, no tie to the app) must survive the app's close
+                control(scratch, "profile", "create", "terminal-1", "--from-config", str(scratch.models / "strata-stub2.json"))
+                terminal = control(scratch, "runtime", "start", "--profile", "terminal-1", "--wait", "60")
+                if terminal.get("state") != "ready":
+                    raise RuntimeError(f"the Terminal's service did not start: {terminal}")
+                terminal_pids = {r["pid"] for r in procs.records(profile="terminal-1")} | {runtime._read_state("terminal-1")["host_pid"]}
+            state = app.load("stub")
+            if how == "two-engines":
+                state = app.load("stub2", multiple=True)
+            engine_ports = [i["port"] for i in state["instances"]]
+            idents, _ = tree_of(app, slots)
+            kinds = sorted({("engine" if "engine" in " ".join(i.cmd) else "server" if "serve.server" in " ".join(i.cmd) else
+                             "owner" if "strata_control.runtime" in " ".join(i.cmd) else "app" if "strata-desktop" in i.cmd[0].lower()
+                             else "host" if "node" in i.cmd[0].lower() else "other") for i in idents})
+            note = f"tree {len(idents)} processes: {', '.join(kinds)}; engine ports {engine_ports}"
+            t0 = time.monotonic()
+            if how == "normal-close":
+                subprocess.run(["taskkill", "/PID", str(app.proc.pid)], capture_output=True)
+            elif how in ("window-x", "two-engines", "window-x-terminal-engine"):
+                hwnd = main_window(app.proc.pid)
+                if not hwnd:
+                    raise RuntimeError("no main window")
+                user32.PostMessageW(hwnd, WM_CLOSE, 0, 0)
+            elif how == "kill-app":
+                subprocess.run(["taskkill", "/F", "/PID", str(app.proc.pid)], capture_output=True)
+            elif how == "host-crash":
+                host = app.host()
+                subprocess.run(["taskkill", "/F", "/PID", str(host.pid)], capture_output=True)
+            elif how == "second-launch":
+                second = subprocess.Popen([str(install / "strata-desktop.exe")], cwd=install, env=scratch.env,
+                                          stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                try:
+                    code = second.wait(timeout=30)
+                except subprocess.TimeoutExpired:
+                    second.kill()
+                    problems.append("the second launch did not exit")
+                    code = None
+                time.sleep(2)
+                hosts = [p for p in psutil.process_iter(["name", "pid"]) if p.info["name"].lower() == "node.exe"
+                         and (p.parent() and p.parent().pid == app.proc.pid)]
+                apps = [p for p in psutil.process_iter(["name"]) if p.info["name"].lower() == "strata-desktop.exe"]
+                if app.proc.poll() is not None:
+                    problems.append("the first app went away")
+                if len(apps) != 1:
+                    problems.append(f"{len(apps)} app processes (want 1)")
+                if len(hosts) != 1:
+                    problems.append(f"{len(hosts)} hosts under the first app (want 1)")
+                after, _ = tree_of(app, slots)
+                new = [i for i in after if i.pid not in {x.pid for x in idents}]
+                if new:
+                    problems.append(f"the second launch started: {[' '.join(i.cmd)[:60] for i in new]}")
+                note += f"; second launch exit code {code}, app processes {len(apps)}, hosts {len(hosts)}"
+                subprocess.run(["taskkill", "/PID", str(app.proc.pid)], capture_output=True)
+            if how == "host-crash":
+                # the shell and its window stay (nothing here restarts a dead host); the host, Control's owner, the server and
+                # the engine must not
+                idents = [i for i in idents if any(k in " ".join(i.cmd) for k in ("strata_control.runtime", "serve.server", "engine", "node.exe"))]
+            left = wait_gone(idents, 90)
+            if left:
+                problems.append(f"processes left: {left}")
+            for port in engine_ports:
+                deadline = time.monotonic() + 10
+                while port_open(port) and time.monotonic() < deadline:
+                    time.sleep(0.2)
+                if port_open(port):
+                    problems.append(f"engine port {port} still open")
+            if terminal is None and not lease_free():
+                problems.append("lease still held")
+            marks = sorted(p.name for p in scratch.mark.iterdir())
+            if terminal is not None:
+                status = control(scratch, "runtime", "status", "--profile", "terminal-1")
+                alive_pids = [p for p in terminal_pids if procs.start_token(p)]
+                if status.get("state") != "ready" or len(alive_pids) != len(terminal_pids):
+                    problems.append(f"closing the app disturbed the Terminal's service: {status.get('state')}, alive {alive_pids} of {sorted(terminal_pids)}")
+                note += f"; the Terminal's service is {status.get('state')} after the app closed"
+                stopped = control(scratch, "runtime", "stop", "--profile", "terminal-1", "--wait", "30")
+                if stopped.get("state") != "stopped" or [p for p in terminal_pids if procs.start_token(p)]:
+                    problems.append(f"the Terminal's service did not stop on request: {stopped}")
+                time.sleep(1)
+                if not lease_free():
+                    problems.append("lease still held after the Terminal's service stopped")
+            if how in ("normal-close", "window-x", "two-engines", "second-launch", "window-x-terminal-engine") and not ({"quit", "eof"} & set(marks)):
+                problems.append(f"the engine was not stopped the clean way (marks {marks})")
+            seconds = round(time.monotonic() - t0, 1)
+            if how == "host-crash":
+                subprocess.run(["taskkill", "/PID", str(app.proc.pid)], capture_output=True)
+                note += "; the app shell stays open after a host crash (by design today)"
+            # the slot must be usable again: stopping a lost owner's slot cleans its state; nothing blocks the next load
+            for slot in slots:
+                res = stop_cli(scratch, slot)
+                already = "not managed or is stopped" in json.dumps(res)       # nothing was left to stop: the clean outcome
+                if res.get("state") not in ("stopped",) and not already:
+                    problems.append(f"runtime stop {slot} after the close: {res}")
+                if runtime._read_state(slot) is not None:
+                    problems.append(f"state of {slot} left behind")
+            return {"name": f"app-{how}", "ok": not problems, "problems": problems, "seconds": seconds, "marks": marks, "note": note}
+        except Exception as exc:  # noqa: BLE001
+            return {"name": f"app-{how}", "ok": False, "problems": [f"{type(exc).__name__}: {exc}"] + problems, "note": note}
+        finally:
+            for p in psutil.process_iter(["name", "exe"]):
+                try:
+                    if (p.info["exe"] or "").lower().startswith(str(install).lower()):
+                        p.kill()
+                except psutil.Error:
+                    pass
+            for r in procs.records():
+                try:
+                    psutil.Process(r["pid"]).kill()
+                except psutil.Error:
+                    pass
+            os.environ.clear(); os.environ.update(saved)
+
+
+SCENARIOS = ["normal-close", "window-x", "window-x-terminal-engine", "kill-app", "host-crash", "second-launch", "two-engines"]
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--install", required=True)
+    ap.add_argument("--scenarios", default="all")
+    ap.add_argument("--report")
+    a = ap.parse_args()
+    names = SCENARIOS if a.scenarios == "all" else a.scenarios.split(",")
+    results = []
+    for how in names:
+        r = case(how, Path(a.install), how)
+        results.append(r)
+        print(("PASS " if r["ok"] else "FAIL ") + r["name"], r.get("seconds", ""), r.get("problems") or "", r.get("note", ""), flush=True)
+    if a.report:
+        Path(a.report).write_text(json.dumps({"platform": "windows", "engine": "fake", "results": results}, indent=1), encoding="utf-8")
+    return 0 if all(r["ok"] for r in results) else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * The Graphics cards choice of the app, end to end on a box with two cards, through the installed app layout (packaged host + bundled Control + a real
+ * engine component): the model list carries the options (one rule, strata_control/gpu_fit.py), a model that fits one card recommends that card, then
+ *   load with ONE card -> answers, only that card holds the model;  load with BOTH cards (the layer split) -> answers, both cards hold the model.
+ *
+ *   node cards-e2e.mjs --install <folder with node/ host/ control/> --components <folder holding engine/<package>> --work <scratch> \
+ *        --family qwen --model IQ3_XXS --data <data folder that has the model files> [--smi "nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits"]
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') || all[i + 1] === undefined ? true : all[i + 1]]] : acc), []));
+for (const need of ['install', 'components', 'work', 'model']) if (!args[need]) { console.error('missing --' + need); process.exit(2); }
+const install = resolve(args.install), work = resolve(args.work), components = resolve(args.components), family = String(args.family ?? 'qwen'), modelId = String(args.model);
+const node = join(install, 'node', 'node'), hostEntry = join(install, 'host', 'server', 'index.mjs');
+const dirs = { models: join(work, 'models'), profiles: join(work, 'profiles'), runtime: join(work, 'runtime'), home: join(work, 'home'), xdg: join(work, 'xdg'), appdata: join(work, 'appdata') };
+for (const d of [dirs.models, dirs.home, dirs.xdg, dirs.appdata]) mkdirSync(d, { recursive: true });
+const delay = ms => new Promise(r => setTimeout(r, ms));
+let failed = false;
+const record = (name, ok, detail = '') => { if (!ok) failed = true; console.log(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail ? '  ' + String(detail).slice(0, 500) : ''}`); };
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+const env = { ...process.env, STRATA_COMPONENTS_DIR: components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime, STRATA_INSTALL_DIR: dirs.models,
+  STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(work, 'models-unused'), APPDATA: dirs.appdata, XDG_CONFIG_HOME: dirs.xdg, PYTHONDONTWRITEBYTECODE: '1' };
+delete env.STRATA_API_KEY;
+const port = await freePort();
+const base = `http://127.0.0.1:${port}`;
+const host = spawn(node, [hostEntry], { cwd: join(install, 'host'), stdio: ['ignore', 'pipe', 'pipe'],
+  env: { ...env, STRATA_PORT: String(port), STRATA_DIST: join(install, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1',
+    STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()) } });
+let hostLog = '';
+host.stdout.on('data', c => { hostLog += c; }); host.stderr.on('data', c => { hostLog += c; });
+const call = async (path, method = 'GET', body) => {
+  const response = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: response.status, body: await response.json().catch(() => null) };
+};
+async function waitJob(id, seconds) {
+  let last = '';
+  for (let i = 0; i < seconds * 2; i++) {
+    const state = (await call('/api/native')).body;
+    const job = state.jobs.find(j => j.id === id);
+    if (job && job.summary !== last) { last = job.summary; console.log('    ... ' + String(last).slice(0, 120)); }
+    if (job && job.state !== 'running') return { job, state };
+    await delay(500);
+  }
+  throw new Error('operation did not finish');
+}
+const smi = () => {
+  const cmd = String(args.smi ?? 'nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits').split(' ');
+  const r = spawnSync(cmd[0], cmd.slice(1), { encoding: 'utf8' });
+  return (r.stdout ?? '').split('\n').map(s => Number(s.trim())).filter(Number.isFinite);
+};
+async function chatPong(instance) {
+  const chat = await call('/v1/chat/completions', 'POST', { model: instance?.apiModelId ?? modelId.toLowerCase(), max_tokens: 400, stream: false, temperature: 0, messages: [{ role: 'user', content: 'Reply with exactly one word: pong' }] });
+  const m = chat.body?.choices?.[0]?.message ?? {};
+  return { ok: chat.status === 200 && /pong/i.test(`${m.content ?? ''}`), text: `${m.content ?? ''}`.slice(0, 60), status: chat.status };
+}
+async function main() {
+  let up = false;
+  for (let i = 0; i < 200 && !up; i++) { try { up = (await fetch(base + '/api/health')).ok; } catch { /* not yet */ } if (!up) await delay(150); }
+  record('host healthy', up, up ? base : hostLog.slice(-500));
+  if (!up) return;
+  const packages = existsSync(join(components, 'engine')) ? readdirSync(join(components, 'engine')) : [];
+  record('an engine component is installed', packages.length > 0, packages.join(', '));
+
+  // ---- the model list carries the choice
+  const native = (await call('/api/native?refresh=1')).body;
+  const gpus = native.hardware?.gpus ?? [];
+  record('the host sees two or more graphics cards', gpus.filter(g => g.usable !== false).length >= 2, JSON.stringify(gpus.map(g => ({ i: g.index, n: g.name, gb: g.vram_gb }))));
+  const size = native.catalog?.families?.find(f => f.family === family)?.sizes.find(s => s.model === modelId);
+  const opt = size?.gpu_options;
+  record('the model list offers the cards choice for this model', !!opt && opt.options.length >= 2, JSON.stringify(opt?.options?.map(o => ({ key: o.key, cards: o.cards, verdict: o.verdict, rec: o.recommended }))));
+  record('a model that fits one card recommends the single largest card (the split is offered, not forced)', opt?.recommended === 'single' && opt.options.find(o => o.key === 'split'), `recommended=${opt?.recommended}`);
+  const single = opt?.options.find(o => o.key === 'single')?.cards ?? [0];
+  const both = opt?.options.find(o => o.key === 'split')?.cards ?? [0, 1];
+
+  // ---- Download and prepare with the recommended card
+  const values = { family, model: modelId, context: 32768, vision: 'no', gpu: single[0], ...(args.data ? { data_dir: resolve(args.data) } : {}) };
+  const started = await call('/api/native/operations', 'POST', { kind: 'install', args: values });
+  record('the install operation starts', started.status === 200 || started.status === 202, JSON.stringify(started.body).slice(0, 160));
+  const done = await waitJob(started.body.id, 3600);
+  record('Download and prepare finishes', done.job.state === 'done', `${done.job.state} ${done.job.error ?? done.job.summary}`);
+  const installed = (await call('/api/native?refresh=1')).body.installed?.models?.find(m => String(m.model).toLowerCase() === modelId.toLowerCase());
+  const model = installed?.model ?? modelId.toLowerCase();
+
+  for (const [label, cards] of [['ONE card', single], ['BOTH cards (layer split)', both]]) {
+    const before = smi();
+    const load = await call('/api/native/operations', 'POST', { kind: 'load', args: { model, gpus: cards } });
+    const loaded = await waitJob(load.body.id, 900);
+    const instance = loaded.state.instances[0];
+    record(`load with ${label} starts the engine`, loaded.job.state === 'done' && instance?.status === 'ready', `${loaded.job.state} ${loaded.job.error ?? ''}; instance=${instance?.status}; gpus=${JSON.stringify(instance?.gpus)}`);
+    record(`the instance runs on exactly the chosen card(s)`, JSON.stringify([...(instance?.gpus ?? [])].sort()) === JSON.stringify([...cards].sort()), `want ${JSON.stringify(cards)} got ${JSON.stringify(instance?.gpus)}`);
+    await delay(3000);
+    const used = smi();
+    const holding = used.map((mb, i) => (mb - (before[i] ?? 0)) > 1000 ? i : -1).filter(i => i >= 0);
+    record(`only the chosen card(s) hold the model (graphics memory in use: ${used.join(', ')} MiB)`, JSON.stringify(holding) === JSON.stringify([...cards].sort()), `holding ${JSON.stringify(holding)}`);
+    const pong = await chatPong(instance);
+    record(`it answers (${label})`, pong.ok, `${pong.status} ${JSON.stringify(pong.text)}`);
+    const unloaded = await call(`/api/native/instances/${instance?.id}/unload`, 'POST', {});
+    record(`unload (${label})`, unloaded.status === 200, unloaded.status);
+    await delay(4000);
+  }
+}
+try { await main(); } catch (e) { record('run', false, e.stack ?? e); }
+host.kill();
+await delay(1500);
+console.log(failed ? 'CARDS-E2E FAIL' : 'CARDS-E2E PASS');
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,72 @@
+# Fetch and verify the private Node runtime the Windows desktop bundle ships (win-x64).
+#
+# The PowerShell twin of fetch-node.sh: same pinned version, same SHA-256 pin, same refusal to
+# install anything whose digest does not match. Not committed output: node.exe is a ~90 MB binary.
+#
+# Usage:
+#   powershell -NoProfile -ExecutionPolicy Bypass -File apps\desktop\scripts\fetch-node.ps1
+#   ... -File fetch-node.ps1 -Check                  # verify what is already installed
+#   ... -File fetch-node.ps1 -FromFile node.zip      # verify and install a zip you already have (offline)
+#
+# The Node version must satisfy the App Host's own engines.node (>= 24.12.0).
+[CmdletBinding()]
+param(
+    [switch]$Check,
+    [string]$FromFile = '',
+    [string]$Dest = ''
+)
+$ErrorActionPreference = 'Stop'
+
+$NodeVersion = if ($env:STRATA_NODE_VERSION) { $env:STRATA_NODE_VERSION } else { '24.12.0' }
+$Target = 'win-x64'
+# SHA-256 of node-v24.12.0-win-x64.zip from nodejs.org's SHASUMS256.txt; keep equal to fetch-node.sh.
+$Expected = '9c125f61ae947b52e779095830f9cac267846a043ef7192183c84016aaad2812'
+if (-not $Dest) { $Dest = Join-Path $PSScriptRoot '..\src-tauri\resources\node' }
+$Installed = Join-Path $Dest 'node.exe'
+
+function Fail([string]$Message) { [Console]::Error.WriteLine("fetch-node: $Message"); exit 1 }
+
+if ($Check) {
+    if (-not (Test-Path -LiteralPath $Installed)) { Fail "not installed at $Installed" }
+    $got = (& $Installed --version).Trim()
+    Write-Output "fetch-node: $Installed is $got"
+    if ($got -ne "v$NodeVersion") { Fail "expected v$NodeVersion" }
+    exit 0
+}
+
+$Archive = "node-v$NodeVersion-$Target.zip"
+$Work = Join-Path ([IO.Path]::GetTempPath()) ("strata-node-" + [Guid]::NewGuid().ToString('N'))
+New-Item -ItemType Directory -Path $Work | Out-Null
+try {
+    $Zip = Join-Path $Work $Archive
+    if ($FromFile) {
+        Copy-Item -LiteralPath $FromFile -Destination $Zip
+    } else {
+        $Url = "https://nodejs.org/dist/v$NodeVersion/$Archive"
+        Write-Output "fetch-node: $Url"
+        [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+        $ProgressPreference = 'SilentlyContinue'
+        Invoke-WebRequest -UseBasicParsing -Uri $Url -OutFile $Zip
+    }
+    $Actual = (Get-FileHash -Algorithm SHA256 -LiteralPath $Zip).Hash.ToLowerInvariant()
+    if ($NodeVersion -ne '24.12.0') {
+        # another version has no recorded digest: say so rather than implying a verification
+        [Console]::Error.WriteLine("fetch-node: WARNING - no recorded digest for v$NodeVersion; this download is NOT authenticated.")
+        [Console]::Error.WriteLine("fetch-node: computed sha256 $Actual - record it in this script and fetch-node.sh.")
+    } elseif ($Actual -ne $Expected) {
+        Fail "REFUSING - $Archive hashes $Actual, expected $Expected"
+    } else {
+        Write-Output 'fetch-node: sha256 verified against the recorded digest'
+    }
+    Add-Type -AssemblyName System.IO.Compression.FileSystem
+    $zipFile = [IO.Compression.ZipFile]::OpenRead($Zip)
+    try {
+        $entry = $zipFile.GetEntry("node-v$NodeVersion-$Target/node.exe")
+        if (-not $entry) { Fail "node.exe is not inside $Archive" }
+        New-Item -ItemType Directory -Force -Path $Dest | Out-Null
+        [IO.Compression.ZipFileExtensions]::ExtractToFile($entry, $Installed, $true)
+    } finally { $zipFile.Dispose() }
+    Write-Output "fetch-node: installed at $Installed"
+} finally {
+    Remove-Item -LiteralPath $Work -Recurse -Force -ErrorAction SilentlyContinue
+}
@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# Fetch and verify the private Node runtime the desktop bundle ships.
+#
+# The App Host is an ordinary Node program, and the packaging requirement is that an end user
+# supplies no runtime of their own. The desktop bundle therefore carries a pinned standalone Node
+# beside the host.
+#
+# It is NOT committed. It is a ~117 MB platform binary: committing it would bloat every clone, it
+# cannot be reviewed in a diff, and it is not source. This script is the reproducible substitute —
+# it downloads the official build for the target and refuses to install anything whose SHA-256 does
+# not match the recorded digest.
+#
+# Usage:
+#   apps/desktop/scripts/fetch-node.sh                 # host platform
+#   apps/desktop/scripts/fetch-node.sh --target linux-x64
+#   apps/desktop/scripts/fetch-node.sh --check         # verify what is already installed
+#
+# The Node version must satisfy the App Host's own `engines.node` (>= 24.12.0).
+set -euo pipefail
+
+NODE_VERSION="${STRATA_NODE_VERSION:-24.12.0}"
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DEST="$HERE/../src-tauri/resources/node"
+
+# Published SHA-256 of each official nodejs.org archive, recorded so a tampered or truncated
+# download is refused rather than shipped. Add a row when bumping the version.
+# Taken from nodejs.org's own SHASUMS256.txt for v24.12.0, which is published over HTTPS beside
+# the archives. Recorded here so the fetch is verified against a value that does not come from the
+# same response as the payload.
+digest_for() {
+  case "$1" in
+    darwin-arm64) echo "319f221adc5e44ff0ed57e8a441b2284f02b8dc6fc87b8eb92a6a93643fd8080" ;;
+    linux-x64)    echo "6159227e0af7d7c3c6bb2fa900452b04a6cb8841a702a79acc613209d70b04d0" ;;
+    linux-arm64)  echo "9b2a2eeb98a8eb37361224e2a1d060300ad2dd143af58dfdb16de785df0f1228" ;;
+    win-x64)      echo "9c125f61ae947b52e779095830f9cac267846a043ef7192183c84016aaad2812" ;;
+    *)            echo "" ;;
+  esac
+}
+
+target() {
+  if [ "${1:-}" = "--target" ]; then echo "${2:?--target needs a value}"; return; fi
+  case "$(uname -s)-$(uname -m)" in
+    Darwin-arm64) echo darwin-arm64 ;;
+    Linux-x86_64) echo linux-x64 ;;
+    Linux-aarch64) echo linux-arm64 ;;
+    MINGW*|MSYS*|CYGWIN*) echo win-x64 ;;
+    *) echo "unsupported host: $(uname -s)-$(uname -m)" >&2; exit 2 ;;
+  esac
+}
+
+TARGET="$(target "$@")"
+EXE="node"
+case "$TARGET" in win-*) EXE="node.exe" ;; esac
+INSTALLED="$DEST/$EXE"
+
+if [ "${1:-}" = "--check" ]; then
+  if [ ! -x "$INSTALLED" ]; then echo "fetch-node: not installed at $INSTALLED" >&2; exit 1; fi
+  got="$("$INSTALLED" --version)"
+  echo "fetch-node: $INSTALLED is $got"
+  case "$got" in "v$NODE_VERSION") exit 0 ;; *) echo "fetch-node: expected v$NODE_VERSION" >&2; exit 1 ;; esac
+fi
+
+# The official archive for this target.
+case "$TARGET" in
+  darwin-arm64) ARCHIVE="node-v$NODE_VERSION-darwin-arm64.tar.gz" ;;
+  darwin-x64)   ARCHIVE="node-v$NODE_VERSION-darwin-x64.tar.gz" ;;
+  linux-x64)    ARCHIVE="node-v$NODE_VERSION-linux-x64.tar.gz" ;;
+  linux-arm64)  ARCHIVE="node-v$NODE_VERSION-linux-arm64.tar.gz" ;;
+  win-x64)      ARCHIVE="node-v$NODE_VERSION-win-x64.zip" ;;
+  *) echo "fetch-node: no archive known for $TARGET" >&2; exit 2 ;;
+esac
+URL="https://nodejs.org/dist/v$NODE_VERSION/$ARCHIVE"
+
+EXPECTED="$(digest_for "$TARGET")"
+WORK="$(mktemp -d "${TMPDIR:-/tmp}/strata-node.XXXXXX")"     # GNU mktemp needs the X template; BSD accepts it too
+trap 'rm -rf "$WORK"' EXIT
+
+echo "fetch-node: $URL"
+curl -fsSL -o "$WORK/$ARCHIVE" "$URL"
+
+ACTUAL="$(shasum -a 256 "$WORK/$ARCHIVE" 2>/dev/null | cut -d' ' -f1 || sha256sum "$WORK/$ARCHIVE" | cut -d' ' -f1)"
+if [ -n "$EXPECTED" ]; then
+  if [ "$ACTUAL" != "$EXPECTED" ]; then
+    echo "fetch-node: REFUSING — $ARCHIVE hashes $ACTUAL, expected $EXPECTED" >&2
+    exit 1
+  fi
+  echo "fetch-node: sha256 verified against the recorded digest"
+else
+  # Without a recorded digest the download cannot be authenticated. Say so loudly and keep the
+  # computed value so it can be recorded, rather than implying a verification that did not happen.
+  echo "fetch-node: WARNING — no recorded digest for $TARGET; this download is NOT authenticated." >&2
+  echo "fetch-node: computed sha256 $ACTUAL — record it in $(basename "${BASH_SOURCE[0]}") to enable verification." >&2
+fi
+
+mkdir -p "$DEST"
+case "$ARCHIVE" in
+  *.zip) unzip -q -j "$WORK/$ARCHIVE" "node-v$NODE_VERSION-win-x64/node.exe" -d "$DEST" ;;
+  *)     tar xzf "$WORK/$ARCHIVE" -C "$WORK"
+         cp "$WORK/node-v$NODE_VERSION-$TARGET/bin/node" "$DEST/node" ;;
+esac
+chmod +x "$DEST/$EXE"
+
+echo "fetch-node: installed $("$DEST/$EXE" --version) at $DEST/$EXE"
@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * The first run of the installed app, headless: the host as the Tauri shell starts it (STRATA_PACKAGED=1, STRATA_NO_ACQUIRE=1,
+ * the staged Control, nothing installed, nothing in the per-user folders) and Chrome on its onboarding.
+ *
+ *   node apps/desktop/scripts/first-run-ui.mjs [--control <staged control>] [--node <node.exe>] [--work <scratch>] [--shots <dir>]
+ *
+ * Checks, one line each (exit 1 if any fails):
+ *   the host answers; /api/native has a real catalog (families with sizes), a recommendation and the GPUs of this PC
+ *   (from Control's bundled installer on Control's Python); the page shows "Let's get started", and after it the model
+ *   list with sizes (no "couldn't show this screen"); no page error; the install plan for the recommended model is a
+ *   plan (nothing is downloaded or started: a plan changes nothing); the spy sees no pip/git/compiler/engine fetch.
+ * Per-user folders (STRATA_HOME, APPDATA, LOCALAPPDATA, the components and install folders) are all under --work.
+ * No model is downloaded and no engine runs.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') ? true : all[i + 1]]] : acc), []));
+const here = dirname(fileURLToPath(import.meta.url));
+const repoHost = resolve(here, '../../host');
+const staged = resolve(here, '../src-tauri/resources');
+const control = resolve(args.control ?? join(staged, 'control'));
+const nodeExe = resolve(args.node ?? join(staged, 'node', process.platform === 'win32' ? 'node.exe' : 'node'));
+const work = resolve(args.work ?? mkdtempSync(join(tmpdir(), 'strata-first-run-')));
+const shots = resolve(args.shots ?? join(work, 'shots'));
+mkdirSync(work, { recursive: true }); mkdirSync(shots, { recursive: true });
+const spy = pathToFileURL(join(repoHost, 'tests/helpers/acquire-spy.mjs')).href;
+const spyLog = join(work, 'spy.log'); writeFileSync(spyLog, '');
+
+const { chromium } = await import(pathToFileURL(join(repoHost, 'node_modules/playwright-core/index.mjs')).href).catch(() => import('playwright-core'));
+const CHROME = process.env.CHROME ?? ['C:/Program Files/Google/Chrome/Application/chrome.exe', '/usr/bin/google-chrome', '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'].find(existsSync);
+
+let failed = false;
+const check = (ok, label, detail = '') => { console.log(`${ok ? 'ok  ' : 'FAIL'} ${label}${detail ? '  ' + detail : ''}`); if (!ok) failed = true; };
+const delay = ms => new Promise(r => setTimeout(r, ms));
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+
+for (const need of [nodeExe, join(control, 'strata.py'), join(repoHost, 'dist', 'index.html')]) if (!existsSync(need)) { console.error(`missing ${need} (run stage-control.py, fetch-node and "npm run build" in apps/host first)`); process.exit(2); }
+
+const dirs = { home: join(work, 'home'), appdata: join(work, 'appdata'), local: join(work, 'local'), components: join(work, 'local', 'Strata', 'components') };
+for (const d of Object.values(dirs)) mkdirSync(d, { recursive: true });
+const port = await freePort();
+const env = {
+  ...process.env,
+  STRATA_PORT: String(port), STRATA_DIST: join(repoHost, 'dist'), STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1',
+  STRATA_CONTROL_DIR: control, STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(work, 'models'), STRATA_COMPONENTS_DIR: dirs.components,
+  APPDATA: dirs.appdata, LOCALAPPDATA: dirs.local, XDG_CONFIG_HOME: join(work, 'xdg'), XDG_DATA_HOME: join(work, 'xdgdata'),
+  STRATA_PROFILE_DIR: join(work, 'profiles'), STRATA_RUNTIME_DIR: join(work, 'runtime'), ACQUIRE_SPY_LOG: spyLog,
+};
+delete env.STRATA_INSTALL_DIR;
+mkdirSync(env.STRATA_MODELS_DIR, { recursive: true });
+const host = spawn(nodeExe, [...(args['no-spy'] === undefined ? ['--import', spy] : []), join(repoHost, 'server', 'index.mjs')], { cwd: repoHost, env, stdio: ['ignore', 'pipe', 'pipe'] });
+let hostLog = '';
+host.stdout.on('data', c => { hostLog += c; }); host.stderr.on('data', c => { hostLog += c; });
+const base = `http://127.0.0.1:${port}`;
+const api = async (path, init) => { const r = await fetch(base + path, init); return { status: r.status, body: await r.json().catch(() => null) }; };
+
+let browser;
+try {
+  let up = false;
+  for (let i = 0; i < 150 && !up; i++) { try { up = (await api('/api/health')).status === 200; } catch { await delay(200); } }
+  check(up, 'the packaged host starts', `port ${port}`);
+  if (!up) throw new Error(hostLog.slice(-2000));
+
+  const native = await api('/api/native?refresh=1');
+  const state = native.body;
+  check(native.status === 200 && state?.available === true, 'the host reads Control', state?.error ?? '');
+  const sizes = (state?.catalog?.families ?? []).reduce((n, f) => n + (f.sizes?.length ?? 0), 0);
+  check((state?.catalog?.families?.length ?? 0) > 0 && sizes >= 3, 'the catalog has real families and sizes', `${state?.catalog?.families?.length} families, ${sizes} sizes`);
+  check(!!state?.catalog?.recommendation, 'the catalog has a recommendation', JSON.stringify(state?.catalog?.recommendation ?? null).slice(0, 120));
+  check(Array.isArray(state?.hardware?.gpus), 'the hardware lists GPUs', (state?.hardware?.gpus ?? []).map(g => `${g.name} ${g.vram_gb} GB`).join('; ') || 'none on this PC');
+  check(state?.installDir && realpathSync.native(state.installDir).toLowerCase().startsWith(realpathSync.native(work).toLowerCase()), 'models go to a writable per-user folder, not the bundle', state?.installDir);
+  const hw = (await api('/api/hardware')).body;
+  console.log('info host hardware probe:', JSON.stringify((hw?.gpus ?? []).map(g => ({ name: g.name, backend: g.backend, vramGb: g.vramGb, unified: g.unified }))));
+  check(!state?.installerError, 'the bundled installer answers', state?.installerError ?? '');
+
+  browser = await chromium.launch({ executablePath: CHROME, headless: true });
+  const page = await browser.newPage({ viewport: { width: 1400, height: 950 } });
+  const problems = [];
+  page.on('pageerror', e => problems.push(`pageerror: ${e.message}`));
+  await page.goto(base, { waitUntil: 'domcontentloaded' });
+  await page.waitForSelector('text=/Let.s get started|Choose a version|Connect your Strata/i', { timeout: 30000 }).catch(() => {});
+  await page.screenshot({ path: join(shots, '1-welcome.png') });
+  const broken = await page.locator('text=/couldn.t show this screen/i').count();
+  check(broken === 0, 'the first screen renders (not "Strata couldn\'t show this screen")');
+  const start = page.getByRole('button', { name: /get started/i });
+  check(await start.count() > 0, 'the welcome step offers "Let\'s get started"');
+  if (await start.count()) await start.first().click();
+  await page.waitForSelector('text=/Choose a version/i', { timeout: 30000 }).catch(() => {});
+  await delay(1200);
+  await page.screenshot({ path: join(shots, '2-models.png') });
+  check(await page.locator('text=/couldn.t show this screen/i').count() === 0, 'the model step renders');
+  check(await page.getByText(/Choose a version/i).count() > 0, 'the model step lists the versions');
+  const labels = await page.locator('[role=radio]').allInnerTexts();
+  check(labels.length >= 3, 'the versions are the real catalog\'s sizes', labels.map(l => l.replace(/\s+/g, ' ').slice(0, 40)).join(' | '));
+  check(labels.some(l => /\d+\.\d\s*GB/.test(l)), 'each version shows its download size');
+  check(problems.length === 0, 'no page error', problems.join('; '));
+
+  const recommended = state?.catalog?.recommendation;
+  if (recommended?.model) {
+    const plan = await api('/api/native/plan', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ family: recommended.family, model: recommended.model, context: recommended.context, data_dir: join(work, 'Strata-data') }) });
+    check(plan.status === 200 && !!plan.body?.plan, 'the install plan for the recommended model is a plan (nothing downloaded)', plan.body?.summary?.slice(0, 100) ?? JSON.stringify(plan.body).slice(0, 150));
+    check(!existsSync(join(work, 'Strata-data', 'models')), 'a plan wrote no model files');
+  }
+} catch (error) {
+  check(false, 'the run', String(error?.message ?? error).slice(0, 600));
+} finally {
+  await browser?.close().catch(() => {});
+  host.kill();
+  await new Promise(r => host.once('exit', r)); // only the PID this script started
+  const attempts = readFileSync(spyLog, 'utf8').split('\n').filter(Boolean);
+  check(attempts.length === 0, 'the spy saw no pip, git, compiler, engine or internet access', attempts.slice(0, 3).join(' '));
+  console.log(`shots in ${shots}`);
+  if (!args.work) rmSync(work, { recursive: true, force: true, maxRetries: 3 });
+}
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,133 @@
+/**
+ * Turn a pnpm "isolated" node_modules (a virtual store in `.pnpm` full of links) into an ordinary hoisted tree of real folders.
+ *
+ * Why: the installer copies the Harness folder file by file. pnpm's layout is thousands of links (junctions on Windows); a copy
+ * that follows them duplicates every package once per dependent and one that does not breaks on the first dangling link. A hoisted
+ * tree has each package once (nested only where two versions of the same name are needed), no links, and Node resolves it
+ * exactly as it resolves any npm install.
+ *
+ * Algorithm (the one npm uses, in short): the packages the root names come first, at the top. Then, walking each placed package's
+ * own dependencies: look the name up from the package's own folder upwards; if the same instance is already visible, nothing to
+ * do; if a DIFFERENT instance of that name is visible, nest this one inside the dependent; if none is visible, hoist it to the top.
+ *
+ * @param {string} out        folder holding `node_modules`
+ * @param {{skip?: RegExp}} [options]  package names never copied (the caller removes them anyway)
+ * @returns {{packages:number, copied:number, nested:number}}
+ */
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync } from 'node:fs';
+import { dirname, join, relative, sep } from 'node:path';
+
+export function flattenPnpm(out, { skip = null } = {}) {
+  const nm = join(out, 'node_modules');
+  const store = join(nm, '.pnpm');
+  const flatRoot = join(out, 'node_modules.flat');
+  rmSync(flatRoot, { recursive: true, force: true });
+  mkdirSync(join(flatRoot, 'node_modules'), { recursive: true });
+
+  const manifest = dir => { try { return JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')); } catch { return null; } };
+  const nameOf = dir => manifest(dir)?.name ?? null;
+  /**
+   * What makes two instances "the same package": name and version. pnpm keeps one copy per set of peer packages (the same workspace
+   * package under many hashed folders); in one hoisted tree they are one package.
+   */
+  const identity = dir => { const m = manifest(dir); return m ? `${m.name}@${m.version}` : dir; };
+  /** The sibling links of a store instance: its dependencies, by name -> real instance folder. */
+  function storeDeps(instance, name) {
+    const container = name.startsWith('@') ? dirname(dirname(instance)) : dirname(instance);
+    const found = new Map();
+    for (const e of readdirSync(container, { withFileTypes: true })) {
+      if (e.name === '.bin') continue;
+      const entries = e.name.startsWith('@') ? readdirSync(join(container, e.name), { withFileTypes: true }).map(x => [`${e.name}/${x.name}`, join(container, e.name, x.name)]) : [[e.name, join(container, e.name)]];
+      for (const [dep, p] of entries) {
+        if (dep === name) continue;
+        try { if (lstatSync(p).isSymbolicLink() || existsSync(p)) found.set(dep, realpathSync(p)); } catch { /* a dangling link: the package was removed on purpose */ }
+      }
+    }
+    return found;
+  }
+  /** Every instance in the store by package name, for packages that arrived without a store entry (copied peers). */
+  const byName = new Map();
+  if (existsSync(store)) {
+    for (const id of readdirSync(store, { withFileTypes: true })) {
+      if (!id.isDirectory()) continue;
+      const container = join(store, id.name, 'node_modules');
+      if (!existsSync(container)) continue;
+      for (const e of readdirSync(container, { withFileTypes: true })) {
+        if (e.name === '.bin') continue;
+        const dirs = e.name.startsWith('@') ? readdirSync(join(container, e.name)).map(x => join(container, e.name, x)) : [join(container, e.name)];
+        for (const d of dirs) {
+          let real; try { real = realpathSync(d); } catch { continue; }
+          if (!real.startsWith(store)) continue;       // a link to a workspace package outside the store is handled through the instance table
+          const n = nameOf(real);
+          if (n && !byName.has(n)) byName.set(n, real);
+        }
+      }
+    }
+  }
+
+  const placed = new Map();   // folder (in the flat tree) -> real instance folder it holds
+  let copied = 0, nested = 0;
+
+  const visibleFrom = (chain, name) => {
+    for (const dir of chain) {
+      const slot = join(dir, 'node_modules', ...name.split('/'));
+      if (placed.has(slot)) return { slot, instance: placed.get(slot) };
+    }
+    return null;
+  };
+  const copyInto = (slot, instance) => {
+    mkdirSync(dirname(slot), { recursive: true });
+    cpSync(instance, slot, { recursive: true, dereference: true, filter: f => !relative(instance, f).split(sep).includes('node_modules') });
+    placed.set(slot, identity(instance));
+    copied++;
+  };
+
+  const queue = [];   // { slotDir (folder of the placed package), chain (folders searched upwards), instance, name }
+  const rootChain = [flatRoot];
+  const place = (name, instance, chain, forceHere) => {
+    if (skip?.test(name)) return;
+    const seen = visibleFrom(chain, name);
+    if (seen && seen.instance === identity(instance)) return;
+    const hoist = !seen && !forceHere;
+    const base = hoist ? flatRoot : chain[0];
+    const slot = join(base, 'node_modules', ...name.split('/'));
+    if (placed.has(slot)) return;      // another instance already sits where this one would go (it nests below, handled by the caller's chain)
+    copyInto(slot, instance);
+    if (!hoist && base !== flatRoot) nested++;
+    queue.push({ slotDir: slot, chain: [slot, ...(hoist ? rootChain : chain)], instance, name });
+  };
+
+  // 1. the packages the root names
+  const rootEntries = [];
+  for (const e of readdirSync(nm, { withFileTypes: true })) {
+    if (e.name === '.pnpm' || e.name === '.bin' || e.name.startsWith('.')) continue;
+    const entries = e.name.startsWith('@') ? readdirSync(join(nm, e.name)).map(x => [`${e.name}/${x}`, join(nm, e.name, x)]) : [[e.name, join(nm, e.name)]];
+    for (const [name, p] of entries) rootEntries.push([name, p]);
+  }
+  for (const [name, p] of rootEntries) {
+    let real; try { real = realpathSync(p); } catch { continue; }
+    place(name, real, rootChain, true);
+  }
+  // 2. their dependencies, breadth first
+  while (queue.length) {
+    const { slotDir, chain, instance, name } = queue.shift();
+    let wants;
+    if (instance.startsWith(store)) wants = storeDeps(instance, name);
+    else {
+      // a package copied in without a store entry: its declared requirements, taken from the store by name when not visible yet
+      const m = manifest(instance) ?? {};
+      wants = new Map();
+      for (const dep of [...Object.keys(m.dependencies ?? {}), ...Object.keys(m.peerDependencies ?? {}), ...Object.keys(m.optionalDependencies ?? {})]) {
+        if (visibleFrom(chain, dep)) continue;
+        const real = byName.get(dep);
+        if (real) wants.set(dep, real);
+      }
+    }
+    for (const [dep, real] of wants) place(dep, real, chain, false);
+  }
+
+  rmSync(nm, { recursive: true, force: true });
+  renameSync(join(flatRoot, 'node_modules'), nm);
+  rmSync(flatRoot, { recursive: true, force: true });
+  return { packages: placed.size, copied, nested };
+}
@@ -0,0 +1,52 @@
+/** Strata's output-budget correction for the staged pi-ai copy. */
+import { createHash } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export const HARNESS_BUDGET_PATCH = Object.freeze({
+  id: 'strata-pi-ai-context-safety-v2',
+  package: '@earendil-works/pi-ai',
+  version: '1.1.0',
+  file: 'node_modules/@earendil-works/pi-ai/dist/api/simple-options.js',
+  beforeSha256: '9b3cc0ae6daa86fdc050bc0cb0f3f986401e64ccddbde6757183c9f8ad411be2',
+});
+
+const sha256 = bytes => createHash('sha256').update(bytes).digest('hex');
+const oldClamp = 'const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;';
+// Small windows also need room after tool results; a fixed margin must not
+// consume all remaining estimated space. Keep the old 64K+ calculation.
+const newClamp = `const remaining = model.contextWindow - estimateContextTokens(context).tokens;
+    const safety = model.contextWindow >= 65536 ? CONTEXT_SAFETY_TOKENS
+        : Math.min(CONTEXT_SAFETY_TOKENS, Math.floor(model.contextWindow / 16), Math.max(0, Math.floor(remaining / 2)));
+    const available = remaining - safety;`;
+
+/**
+ * Patch only a flattened, disposable staged Harness. Returns the BUNDLE.json
+ * provenance entry; the caller records it when writing the bundle manifest.
+ * A repeat application or any unknown package/source fails before writing.
+ */
+export function patchStagedHarnessBudget(stagedRoot) {
+  const fail = message => { throw new Error(`Harness output-budget patch: ${message}`); };
+  const root = realpathSync(resolve(stagedRoot));
+  const packageDir = join(root, 'node_modules', '@earendil-works', 'pi-ai');
+  const target = join(root, HARNESS_BUDGET_PATCH.file);
+  let manifest, before;
+  try {
+    manifest = JSON.parse(readFileSync(join(packageDir, 'package.json'), 'utf8'));
+    // Flattening must have removed links; never write through a shared source file.
+    if (realpathSync(target) !== target || !lstatSync(target).isFile() || lstatSync(target).nlink !== 1)
+      fail('expected an unlinked staged module');
+    before = readFileSync(target);
+  } catch (error) {
+    fail(`cannot read a standalone staged pi-ai dependency (${error.message})`);
+  }
+  if (manifest?.name !== HARNESS_BUDGET_PATCH.package || manifest?.version !== HARNESS_BUDGET_PATCH.version)
+    fail('expected @earendil-works/pi-ai 1.1.0; review the patch before staging a different dependency');
+  if (sha256(before) !== HARNESS_BUDGET_PATCH.beforeSha256)
+    fail('unexpected simple-options.js SHA-256; review the dependency source before staging');
+  const source = before.toString('utf8');
+  if (source.split(oldClamp).length !== 2) fail('expected exactly one known context clamp');
+  const after = Buffer.from(source.replace(oldClamp, newClamp));
+  writeFileSync(target, after);
+  return { ...HARNESS_BUDGET_PATCH, afterSha256: sha256(after) };
+}
@@ -0,0 +1,79 @@
+/**
+ * Which files and folders of the staged Harness are dropped, and the check that nothing the Harness imports is gone.
+ *
+ * The 2026-10-17 tester report: on Linux and Mac every agent chat failed ("session/create ... waiting for workflowEngine").
+ * Cause: the old rule "drop any folder named after another operating system" also removed the Harness's own JavaScript package
+ * `@deepseek-ai/dsh-win32-process`. It is plain JS (no binary), and `dsh-subprocess-local` and `dsh-sandbox-local` import it by
+ * name on every platform, so those two plugins failed to load, and everything waiting on them (shell, subprocess, ptcRuntime,
+ * workflowEngine) never started. Windows kept it (the rule differs there), so the Windows tests passed.
+ */
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join, sep } from 'node:path';
+
+export const OTHER_OS = {
+  win32: /(^|[\\/._-])(darwin|linux|android|freebsd|musl)([\\/._-]|$)/i,
+  darwin: /(^|[\\/._-])(win32|linux|android|freebsd|musl)([\\/._-]|$)/i,
+  // Linux: the AppImage bundler (linuxdeploy) resolves the libraries of every ELF file under resources and stops on one it
+  // cannot satisfy (koffi's musl build wants libc.musl). The app is glibc x86_64, so musl and other-CPU builds are dropped.
+  linux: /(^|[\\/._-])(win32|darwin|android|freebsd|musl|arm64|aarch64|armv7|arm|ia32|riscv64|ppc64|s390x|loong64)([\\/._-]|$)/i,
+};
+const NATIVE_FOLDER = /prebuild|bin|native|platform|-(win32|darwin|linux)/i;
+
+/** The Harness's own JavaScript packages (`@deepseek-ai/dsh-*`) are code every platform imports by name; never drop one. */
+export function isHarnessCodePackage(path) {
+  const parts = path.split(sep);
+  const i = parts.lastIndexOf('@deepseek-ai');
+  return i >= 0 && i === parts.length - 2 && parts[i + 1].startsWith('dsh-');
+}
+
+/** True when the folder `path` (a directory named `name`) is another operating system's prebuilt binary and can go. */
+export function isOtherOsBinaryFolder(platform, name, path) {
+  const rule = OTHER_OS[platform] ?? OTHER_OS.linux;
+  if (isHarnessCodePackage(path)) return false;
+  return rule.test(name) && NATIVE_FOLDER.test(path);
+}
+
+/** Imports the Windows copy (which works) is also without: browser-side or dev-only bundles, and the document converter the app drops on purpose. */
+const KNOWN_ABSENT = new Set([
+  '@deepseek-ai/libreoffice-kit', '@deepseek-ai/dsh-client-ui-dockkit', '@deepseek-ai/dsh-client-web',
+  '@deepseek-ai/dsh-experimental-webworker-runtime', '@deepseek-ai/dsh-remote-mock', '@deepseek-ai/dsh-client-test-runtime',
+]);
+
+function jsFiles(dir, out = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isSymbolicLink()) continue;
+    if (e.isDirectory()) jsFiles(p, out);
+    else if (/\.(m?js|cjs)$/.test(e.name)) out.push(p);
+  }
+  return out;
+}
+
+/**
+ * Every bare `@deepseek-ai/<package>` the staged Harness's own packages import (static `from "x"` and `import("x")`) must exist
+ * in the staged node_modules. Returns the list of `{from, missing}` problems (empty = good). Plugins that are only loaded on
+ * another platform still count: Node resolves a static import whether or not the code runs.
+ */
+export function missingHarnessImports(harnessDir) {
+  const scope = join(harnessDir, 'node_modules', '@deepseek-ai');
+  if (!existsSync(scope)) return [{ from: scope, missing: '@deepseek-ai (no installed packages)' }];
+  const problems = [];
+  const seen = new Set();
+  const re = /(?:from|import)\s*\(?\s*["'](@deepseek-ai\/[^"'/]+)(?:\/[^"']*)?["']/g;
+  for (const pkg of readdirSync(scope)) {
+    const lib = join(scope, pkg, 'lib');
+    if (!existsSync(lib)) continue;
+    for (const file of jsFiles(lib)) {
+      const text = readFileSync(file, 'utf8');
+      for (const m of text.matchAll(re)) {
+        const name = m[1];
+        const key = `${pkg}>${name}`;
+        if (seen.has(key) || KNOWN_ABSENT.has(name)) continue;
+        seen.add(key);
+        if (!existsSync(join(harnessDir, 'node_modules', ...name.split('/')))
+          && !existsSync(join(scope, pkg, 'node_modules', ...name.split('/')))) problems.push({ from: `${pkg}`, missing: name });
+      }
+    }
+  }
+  return problems;
+}
@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Prove the INSTALLED app layout can start and stop an engine with nothing acquired, using a stub engine.
+ *
+ *   node apps/desktop/scripts/installed-flow.mjs --install <folder the installer wrote> [--work <scratch>] [--spy <acquire-spy.mjs>]
+ *
+ * It starts the installed host with the installed node.exe exactly as the Tauri shell does (STRATA_PACKAGED=1,
+ * STRATA_NO_ACQUIRE=1; Control found beside the host), against a scratch component folder holding a fake engine
+ * package and a scratch install folder holding one run config. Everything per-user (profiles, runtime state, host data,
+ * components) lives under --work, so the real profile of whoever runs this is never read or written.
+ *
+ * Steps (each one printed, the run exits 1 if any fails):
+ *   host health, Control status (engine usable, acquiring forbidden), models from Control, load through the host
+ *   (profile + `runtime start` under the owner runtime), a chat answer from the stub engine, a second client attaches to
+ *   the same owner/instance, unload stops it, no engine for this PC is a notice with nothing started, the Tauri-style
+ *   clean shutdown stops the engines the host started, a hard-killed host takes its engine with it.
+ * With --spy the host runs under tests/helpers/acquire-spy.mjs and the run fails on any attempt to reach the internet or
+ * run an installer.
+ *
+ * REAL mode (a test box with a GPU): --components <folder holding engine/<package>> --models <folder with strata-<id>.json
+ * whose engine is "component:strata-engine"> --model <id> [--backend cuda]. The same host and Control, a real engine and a
+ * real model: load, a real answer, ownership, unload, the missing-engine notice, load again, clean shutdown. The stub-only
+ * steps (the marker file, the hard-kill report) are left out.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, chmodSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') || all[i + 1] === undefined ? true : all[i + 1]]] : acc), []));
+if (!args.install) { console.error('usage: installed-flow.mjs --install <folder> [--work <dir>] [--spy <acquire-spy.mjs>]'); process.exit(2); }
+const install = resolve(args.install);
+const isWin = process.platform === 'win32';
+const node = join(install, 'node', isWin ? 'node.exe' : 'node');
+const hostEntry = join(install, 'host', 'server', 'index.mjs');
+const controlDir = join(install, 'control');
+const python = isWin ? join(controlDir, 'python', 'python.exe') : join(controlDir, 'python', 'bin', 'python3');
+const real = !!args.components;
+const modelId = String(args.model ?? 'stub');
+const work = resolve(args.work ?? mkdtempSync(join(tmpdir(), 'strata-installed-flow-')));
+mkdirSync(work, { recursive: true });
+const dirs = { components: real ? resolve(args.components) : join(work, 'components'), models: real ? resolve(args.models) : join(work, 'models'), profiles: join(work, 'profiles'), runtime: join(work, 'runtime'), home: join(work, 'home') };
+// the runtime and profile folders are created by Control itself, with the owner-only ACL it insists on
+for (const [name, d] of Object.entries(dirs)) if (!['runtime', 'profiles'].includes(name) && !(real && ['components', 'models'].includes(name))) mkdirSync(d, { recursive: true });
+
+const steps = [];
+const record = (name, ok, detail = '') => { steps.push({ name, ok: !!ok, detail: String(detail) }); console.log(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail ? '  ' + detail : ''}`); };
+const delay = ms => new Promise(r => setTimeout(r, ms));
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+const sha = buf => createHash('sha256').update(buf).digest('hex');
+
+// ------------------------------------------------------------------------------ fixtures
+const baseEnv = {
+  ...process.env,
+  STRATA_COMPONENTS_DIR: dirs.components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime,
+  STRATA_INSTALL_DIR: dirs.models, STRATA_ENGINE_BACKEND: String(args.backend ?? 'cuda'), STRATA_HOME: dirs.home, STRATA_MODELS_DIR: real ? join(work, 'models-unused') : dirs.models,
+  APPDATA: join(work, 'appdata'), XDG_CONFIG_HOME: join(work, 'xdg'), PYTHONDONTWRITEBYTECODE: '1',
+};
+delete baseEnv.STRATA_API_KEY;
+mkdirSync(baseEnv.APPDATA, { recursive: true });
+const mark = join(work, 'engine-ran.json');
+
+const FAKE_ENGINE = `import os, sys, json
+from pathlib import Path
+Path(os.environ['FAKE_ENGINE_MARK']).write_text(json.dumps({'pid': os.getpid(), 'script': os.path.abspath(__file__), 'argv': sys.argv[1:]}))
+print('READY 4096 stop', flush=True)
+for line in sys.stdin:
+    if line.strip() == 'QUIT': break
+    if line.startswith(('GEN ', 'BGEN ')):
+        slot = int(line.split()[1]) if line.startswith('BGEN ') else None
+        print('T 97', flush=True)
+        print('DONE 1 1 1.0 1.0 length 0 0 0', flush=True)
+        if slot is not None: print(f'BADM {slot} 0', flush=True)
+`;
+
+function installFakeEngine() {
+  const platform = isWin ? 'windows-x86_64' : 'linux-x86_64';
+  const folder = join(dirs.components, 'engine', `0.1.45-${platform}-cuda`);
+  mkdirSync(folder, { recursive: true });
+  writeFileSync(join(folder, 'engine_main.py'), FAKE_ENGINE);
+  const entry = isWin ? 'engine.cmd' : 'engine';
+  writeFileSync(join(folder, entry), isWin
+    ? `@echo off\r\n"${python}" "%~dp0engine_main.py" %*\r\n`
+    : `#!/bin/sh\nexec "${python}" "$(dirname "$0")/engine_main.py" "$@"\n`);
+  if (!isWin) chmodSync(join(folder, entry), 0o755);
+  const files = [entry, 'engine_main.py'].map(p => { const b = readFileSync(join(folder, p)); return { path: p, sha256: sha(b), bytes: b.length }; });
+  writeFileSync(join(folder, 'engine-component.json'), JSON.stringify({ schema_version: 1, id: 'strata-engine', version: '0.1.45', platform, backend: 'cuda', entrypoint: entry, files }));
+  return folder;
+}
+
+function makeTokenizerAndConfig() {
+  const tok = join(dirs.models, 'tokenizer');
+  mkdirSync(tok, { recursive: true });
+  const script = `import json, sys\nfrom tools.strata_tokenizer import BYTE_TO_UNICODE\ntok = sys.argv[1]\ntokens = [BYTE_TO_UNICODE[i] for i in range(256)] + ['ab', '<|im_start|>', '<|im_end|>', '<|endoftext|>']\njson.dump({t: i for i, t in enumerate(tokens)}, open(tok + '/vocab.json', 'w'))\nopen(tok + '/merges.txt', 'w').write('a b')\njson.dump([0] * 257 + [3, 3, 3], open(tok + '/token_type.json', 'w'))\n`;
+  const done = spawnSync(python, ['-c', script, tok], { cwd: controlDir, env: { ...baseEnv, PYTHONNOUSERSITE: '1' }, encoding: 'utf8' });
+  if (done.status !== 0) throw new Error('tokenizer fixture failed: ' + done.stderr);
+  writeFileSync(join(dirs.models, 'strata-stub.json'), JSON.stringify({ exe: 'component:strata-engine', backend: 'cuda', tokenizer: tok, args: [], cwd: work, model_name: 'stub', host: '127.0.0.1', port: 0 }));
+}
+
+const control = (...argv) => spawnSync(python, [join(controlDir, 'strata.py'), ...argv, '--output', 'json'], { cwd: controlDir, env: { ...baseEnv, PYTHONNOUSERSITE: '1', STRATA_NO_ACQUIRE: '1', FAKE_ENGINE_MARK: mark }, encoding: 'utf8', timeout: 120000 });
+const controlJson = (...argv) => { const r = control(...argv); let json = null; try { json = JSON.parse(r.stdout.slice(r.stdout.indexOf('{'))); } catch { /* not json */ } return { code: r.status, json, text: r.stdout + r.stderr }; };
+const alive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } };
+
+// ------------------------------------------------------------------------------ the host
+let host = null, port = 0, base = '', spyLog = null, shutdownToken = randomBytes(32).toString('hex');
+async function startHost() {
+  port = await freePort(); base = `http://127.0.0.1:${port}`;
+  const hostArgs = [...(args.spy ? ['--import', pathToFileURL(resolve(args.spy)).href] : []), hostEntry];
+  if (args.spy) { spyLog = join(work, 'acquire-spy.log'); writeFileSync(spyLog, ''); }
+  host = spawn(node, hostArgs, {
+    cwd: join(install, 'host'), stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
+    env: { ...baseEnv, STRATA_PORT: String(port), STRATA_DIST: join(install, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1',
+      STRATA_NO_ACQUIRE: '1', STRATA_SHUTDOWN_TOKEN: shutdownToken, FAKE_ENGINE_MARK: mark, STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()),
+      ...(spyLog ? { ACQUIRE_SPY_LOG: spyLog } : {}) },
+  });
+  let log = '';
+  host.stdout.on('data', c => { log += c; }); host.stderr.on('data', c => { log += c; });
+  host.hostLog = () => log;
+  for (let i = 0; i < 200; i++) { try { if ((await fetch(base + '/api/health')).ok) return true; } catch { /* not yet */ } await delay(150); }
+  return false;
+}
+/** The host started the way the Tauri shell starts it, by a stand-in shell (a node process) that can then be killed hard. */
+async function startHostViaShell() {
+  port = await freePort(); base = `http://127.0.0.1:${port}`;
+  const spec = { command: node, args: [hostEntry], options: {
+    cwd: join(install, 'host'), stdio: 'ignore', windowsHide: true,
+    env: { ...baseEnv, STRATA_PORT: String(port), STRATA_DIST: join(install, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1',
+      STRATA_NO_ACQUIRE: '1', STRATA_SHUTDOWN_TOKEN: shutdownToken, STRATA_EXIT_WITH_PARENT: '1', FAKE_ENGINE_MARK: mark,
+      STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()) } } };
+  const shell = spawn(node, ['-e', "const s=JSON.parse(process.env.HOST_SPEC);const c=require('node:child_process').spawn(s.command,s.args,s.options);console.log(c.pid);setInterval(()=>{},1000);"],
+    { env: { ...process.env, HOST_SPEC: JSON.stringify(spec) }, stdio: ['ignore', 'pipe', 'inherit'], windowsHide: true });
+  const hostPid = await new Promise(r => shell.stdout.once('data', c => r(Number(String(c).trim()))));
+  for (let i = 0; i < 200; i++) { try { if ((await fetch(base + '/api/health')).ok) return { shell, hostPid }; } catch { /* not yet */ } await delay(150); }
+  return { shell, hostPid, failed: true };
+}
+const call = async (path, method = 'GET', body) => {
+  const response = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: response.status, body: await response.json().catch(() => null) };
+};
+async function waitJob(id, seconds = 120) {
+  for (let i = 0; i < seconds * 5; i++) {
+    const state = (await call('/api/native')).body;
+    const job = state.jobs.find(j => j.id === id);
+    if (job && job.state !== 'running') return { job, state };
+    await delay(200);
+  }
+  throw new Error('operation did not finish');
+}
+async function stopHost(hard = false) {
+  if (!host || host.exitCode !== null) return;
+  if (hard) { if (isWin) spawnSync('taskkill', ['/PID', String(host.pid), '/T', '/F'], { windowsHide: true }); else host.kill('SIGKILL'); }
+  else host.kill();
+  for (let i = 0; i < 100 && host.exitCode === null; i++) await delay(100);
+}
+
+async function main() {
+  for (const need of [node, hostEntry, python, join(controlDir, 'strata.py')]) if (!existsSync(need)) { record('installed layout', false, `missing ${need}`); return; }
+  record('installed layout', true, install);
+  if (real) {
+    const packages = existsSync(join(dirs.components, 'engine')) ? readdirSync(join(dirs.components, 'engine')) : [];
+    record('fixtures', packages.length > 0 && existsSync(join(dirs.models, `strata-${modelId}.json`)), `engine package(s) ${packages.join(', ')} in ${dirs.components}; run config strata-${modelId}.json in ${dirs.models}`);
+  } else {
+    installFakeEngine();
+    makeTokenizerAndConfig();
+    record('fixtures', true, `stub engine package in ${dirs.components}; run config strata-stub.json`);
+  }
+
+  if (!(await startHost())) { record('host healthy', false, host.hostLog().slice(-600)); return; }
+  record('host healthy', true, base);
+
+  const status = (await call('/api/control/status')).body;
+  record('Control status: bundled, engine usable, acquiring forbidden', status.control?.python?.startsWith(controlDir) && status.engine?.usable === true && status.acquisition?.forbidden === true,
+    `python=${status.control?.python}; engine=${status.engine?.engine?.version}; forbidden=${status.acquisition?.forbidden}`);
+
+  const native = (await call('/api/native?refresh=1')).body;
+  const model = native.installed?.models?.find(m => m.model === modelId);
+  record('models come from Control', native.available && model?.ready === true && native.packaged === true, `available=${native.available}; model ready=${model?.ready}; ${native.summary ?? native.error}`);
+
+  // ---- load
+  const started = (await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } })).body;
+  const loaded = await waitJob(started.id, 400);
+  const instance = loaded.state.instances[0];
+  record('load through the host starts the engine under Control', loaded.job.state === 'done' && instance?.status === 'ready', `job=${loaded.job.state} ${loaded.job.error ?? ''}; instance=${instance?.status}`);
+  let ran = existsSync(mark) ? JSON.parse(readFileSync(mark, 'utf8')) : null;
+  if (real) {
+    const listed = spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => l.includes(`${dirs.components}/engine/`) && l.includes('--serve'));
+    ran = listed.length ? { pid: Number(listed[0].trim().split(/\s+/)[0]), script: listed[0].trim().split(/\s+/)[1] } : null;
+    record('the engine process running is the binary from the component folder', !!ran, listed[0] ? listed[0].trim().slice(0, 160) : 'no engine process under the component folder');
+  } else {
+    record('the engine that ran is the one in the component folder', ran && ran.script.toLowerCase().startsWith(dirs.components.toLowerCase()), ran?.script ?? 'engine never ran');
+  }
+
+  const runtime = controlJson('runtime', 'status', '--profile', 'app-1');
+  record('a second client sees the same owner and instance (ownership)', runtime.json?.state === 'ready' && !!runtime.json.owner_id && !!runtime.json.instance_id && runtime.json.host_pid !== host.pid,
+    `state=${runtime.json?.state}; owner=${String(runtime.json?.owner_id).slice(0, 8)}; instance=${String(runtime.json?.instance_id).slice(0, 8)}; owner host pid ${runtime.json?.host_pid} is not the app host (${host.pid})`);
+
+  // ---- answer
+  const chat = await call('/v1/chat/completions', 'POST', real
+    ? { model: instance?.apiModelId ?? modelId, messages: [{ role: 'user', content: 'Reply with exactly one word: pong' }], max_tokens: 200, temperature: 0, reasoning_effort: 'none', stream: false }
+    : { model: instance?.apiModelId ?? modelId, messages: [{ role: 'user', content: 'hi' }], max_tokens: 4, stream: false });
+  const message = chat.body?.choices?.[0]?.message ?? {};
+  const answer = `${message.content ?? ''}${message.reasoning_content ?? ''}`;   // the stub emits token 97 ("a"); the server files it as reasoning
+  record(real ? 'the real model answers through the host (the answer text is checked)' : 'the engine answers through the host (the stub token, not an error)',
+    chat.status === 200 && (real ? /pong/i.test(answer) : answer === 'a'), `status=${chat.status}; answer=${JSON.stringify(answer.slice(0, 200))}${chat.status === 200 ? '' : ' ' + JSON.stringify(chat.body).slice(0, 160)}`);
+
+  // ---- unload
+  const unloaded = await call(`/api/native/instances/${instance.id}/unload`, 'POST', {});
+  await delay(500);
+  const after = controlJson('runtime', 'status', '--profile', 'app-1');
+  for (let i = 0; i < 100 && ran && alive(ran.pid); i++) await delay(100);       // a real engine takes a moment to release the GPU
+  record('unload stops the engine', unloaded.status === 200 && after.json?.state === 'stopped' && (!ran || !alive(ran.pid)), `status=${unloaded.status}; runtime=${after.json?.state}; engine pid ${ran?.pid} alive=${ran ? alive(ran.pid) : 'n/a'}`);
+
+  // ---- no engine for this PC
+  const hidden = join(dirs.components, real ? 'engine.hidden-by-flow' : 'engine.gone');
+  renameSync(join(dirs.components, 'engine'), hidden);
+  rmSync(mark, { force: true });
+  const missing = await waitJob((await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } })).body.id);
+  record('no engine for this PC is a notice and nothing is started', missing.job.state === 'error' && /No engine for this PC/.test(missing.job.error) && /never downloads/.test(missing.job.error) && !existsSync(mark),
+    `${missing.job.state}: ${String(missing.job.error).slice(0, 160)}`);
+  const refused = await waitJob((await call('/api/native/operations', 'POST', { kind: 'install', args: { family: 'qwen', model: 'IQ2_XS' } })).body.id);
+  record('installing from the app is refused (Terminal only)', refused.job.state === 'error' && /Terminal/.test(refused.job.error), refused.job.error);
+  const binary = await call('/api/engine/binary', 'POST');
+  record('the llama.cpp download route is refused', binary.status === 409 && /never downloads/.test(binary.body?.error ?? ''), `${binary.status} ${binary.body?.error}`);
+
+  // ---- clean shutdown (what the Tauri shell does on exit)
+  renameSync(hidden, join(dirs.components, 'engine'));
+  rmSync(mark, { force: true });
+  const again = await waitJob((await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } })).body.id, 400);
+  let ran2 = existsSync(mark) ? JSON.parse(readFileSync(mark, 'utf8')) : null;
+  if (real) {
+    const listed = spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => l.includes(`${dirs.components}/engine/`) && l.includes('--serve'));
+    ran2 = listed.length ? { pid: Number(listed[0].trim().split(/\s+/)[0]) } : null;
+  }
+  record('load again after the engine package returns', again.job.state === 'done', again.job.error ?? '');
+  const wrong = await fetch(base + '/api/control/shutdown', { method: 'POST', headers: { 'x-strata-shutdown': 'nope' } });
+  record('shutdown without the shell\'s secret is refused', wrong.status === 403, String(wrong.status));
+  const exited = new Promise(r => host.once('exit', code => r(code)));
+  const stopping = await fetch(base + '/api/control/shutdown', { method: 'POST', headers: { 'x-strata-shutdown': shutdownToken } });
+  const code = await Promise.race([exited, delay(90000).then(() => 'timeout')]);
+  for (let i = 0; i < 100 && ran2 && alive(ran2.pid); i++) await delay(100);
+  const final = controlJson('runtime', 'status', '--profile', 'app-1');
+  record('clean shutdown stops the engine the app started and exits', stopping.status === 202 && code === 0 && final.json?.state === 'stopped' && (!ran2 || !alive(ran2.pid)), `status=${stopping.status}; host exit=${code}; runtime=${final.json?.state}; engine alive=${ran2 ? alive(ran2.pid) : 'n/a'}`);
+
+  // ---- hard kill: an engine whose app host dies ends with it (the owner follows the host: runtime start --die-with-pid)
+  if (!(await startHost())) { record('host restarts', false, host.hostLog().slice(-400)); return; }
+  await call('/api/native?refresh=1');
+  rmSync(mark, { force: true });
+  const third = await waitJob((await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } })).body.id, 400);
+  let ran3 = existsSync(mark) ? JSON.parse(readFileSync(mark, 'utf8')) : null;
+  if (real) {
+    const listed = spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => l.includes(`${dirs.components}/engine/`) && l.includes('--serve'));
+    ran3 = listed.length ? { pid: Number(listed[0].trim().split(/\s+/)[0]) } : null;
+    record('(real) the engine is up before the host is killed', !!ran3, listed[0] ? listed[0].trim().slice(0, 120) : 'no engine process');
+  }
+  await stopHost(true);
+  for (let i = 0; i < 600 && ran3 && alive(ran3.pid); i++) await delay(100);       // the owner notices within a second, drains, stops
+  const orphan = controlJson('runtime', 'status', '--profile', 'app-1');
+  record('a hard-killed app host takes its engine with it', third.job.state === 'done' && (!ran3 || !alive(ran3.pid)), `engine alive=${ran3 ? alive(ran3.pid) : 'n/a'}; runtime=${orphan.json?.state ?? orphan.json?.error?.message}`);
+  const cleanup = controlJson('runtime', 'stop', '--profile', 'app-1');
+  record('nothing is left to stop afterwards', /stopped|not managed/.test(JSON.stringify(cleanup.json)) && controlJson('runtime', 'status', '--profile', 'app-1').json?.state === 'stopped', JSON.stringify(cleanup.json).slice(0, 160));
+
+  // ---- the shell itself is killed (what the desktop shell's crash or kill looks like to the host): the host leaves, and
+  // its engine with it, with nothing announced. Windows also has the job object; this is the path that works everywhere.
+  const started2 = await startHostViaShell();
+  if (started2.failed) { record('host starts under a stand-in shell', false, ''); try { started2.shell.kill('SIGKILL'); } catch { /* gone */ } }
+  else {
+    await call('/api/native?refresh=1');
+    rmSync(mark, { force: true });
+    const fourth = await waitJob((await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } })).body.id, 400);
+    let ran4 = existsSync(mark) ? JSON.parse(readFileSync(mark, 'utf8')) : null;
+    if (real) {
+      const listed = spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => l.includes(`${dirs.components}/engine/`) && l.includes('--serve'));
+      ran4 = listed.length ? { pid: Number(listed[0].trim().split(/\s+/)[0]) } : null;
+    }
+    if (isWin) spawnSync('taskkill', ['/PID', String(started2.shell.pid), '/F'], { windowsHide: true }); else started2.shell.kill('SIGKILL');
+    for (let i = 0; i < 100 && alive(started2.hostPid); i++) await delay(100);
+    const hostGone = !alive(started2.hostPid);
+    for (let i = 0; i < 900 && ran4 && alive(ran4.pid); i++) await delay(100);
+    const engineGone = !ran4 || !alive(ran4.pid);
+    record('a killed shell takes the host and its engine with it', fourth.job.state === 'done' && hostGone && engineGone,
+      `host pid ${started2.hostPid} gone=${hostGone}; engine pid ${ran4?.pid} gone=${engineGone}; runtime=${controlJson('runtime', 'status', '--profile', 'app-1').json?.state}`);
+    controlJson('runtime', 'stop', '--profile', 'app-1');
+  }
+
+  await finishSpy();
+}
+
+async function finishSpy() {
+  if (spyLog) {
+    const attempts = readFileSync(spyLog, 'utf8').split('\n').filter(Boolean);
+    record('no acquisition attempt by the host during the whole run (spy)', attempts.length === 0, attempts.join(' | '));
+  }
+}
+
+try { await main(); }
+catch (error) { record('flow', false, error.stack ?? error.message); }
+finally {
+  try { const hid = join(dirs.components, 'engine.hidden-by-flow'); if (real && existsSync(hid) && !existsSync(join(dirs.components, 'engine'))) renameSync(hid, join(dirs.components, 'engine')); } catch { /* reported by the run */ }
+  await stopHost(true);
+  controlJson('runtime', 'stop', '--profile', 'app-1');
+  controlJson('runtime', 'stop', '--profile', 'app-2');
+}
+const failed = steps.filter(s => !s.ok);
+writeFileSync(join(work, 'installed-flow.json'), JSON.stringify({ ok: failed.length === 0, install, work, steps }, null, 1));
+console.log(`\n${steps.length - failed.length}/${steps.length} ok; report ${join(work, 'installed-flow.json')}`);
+if (!args.keep && !args.work && failed.length === 0) { try { rmSync(work, { recursive: true, force: true }); } catch { /* leave it */ } }
+process.exit(failed.length ? 1 : 0);
@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+/**
+ * Mock-ups of the Windows installer in Strata's own look: four screens (welcome, where, installing, done), light and dark, drawn with
+ * the app's built CSS (apps/host/dist) and brand files, then photographed with Chrome. Nothing here is built or shipped: it is what
+ * the owner is shown before an installer is chosen.
+ *
+ *   node apps/desktop/scripts/installer-mockups.mjs [--out <folder>]
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]]] : acc), []));
+const here = dirname(fileURLToPath(import.meta.url));
+const host = resolve(here, '../../host');
+const out = resolve(args.out ?? join(here, '../installer-mockups'));
+mkdirSync(out, { recursive: true });
+const dist = join(host, 'dist');
+const css = readdirSync(join(dist, 'assets')).filter(f => f.endsWith('.css')).map(f => readFileSync(join(dist, 'assets', f), 'utf8')).join('\n');
+const logo = theme => readFileSync(join(dist, 'brand', `strata-lockup-${theme}.svg`), 'utf8');
+const { chromium } = await import(pathToFileURL(join(host, 'node_modules/playwright-core/index.mjs')).href).catch(() => import('playwright-core'));
+const CHROME = process.env.CHROME ?? ['C:/Program Files/Google/Chrome/Application/chrome.exe', '/usr/bin/google-chrome'].find(existsSync);
+
+const check = '<svg class="st-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12.5l4.5 4.5L19 7.5"/></svg>';
+const folder = '<svg class="st-icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M3 7a2 2 0 0 1 2-2h4l2 2h8a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z"/></svg>';
+
+const screens = {
+  welcome: theme => `<header class="onboard-header"><span class="mock-logo">${logo(theme)}</span></header>
+    <div class="onboard-welcome-copy"><h1>State of the art. At home.</h1><p>Strata runs AI on your own computer.<br>Setting it up takes a few minutes.</p>
+    <div class="onboard-benefits"><span>${check}Private</span><span>${check}Fast</span><span>${check}Easy to use</span></div></div>
+    <footer class="onboard-footer onboard-footer--welcome"><button class="st-btn st-btn--primary">Install Strata</button><small>Installs for you only. No administrator needed.</small></footer>`,
+  where: theme => `<header class="onboard-header"><span class="mock-logo">${logo(theme)}</span></header>
+    <div class="mock-body"><h2 class="mock-title">Where should Strata go?</h2><p class="mock-sub">This is the right place for most people.</p>
+    <div class="onboard-folder">${folder}<div><strong>Your Strata folder</strong><small>C:\\Users\\Alex\\AppData\\Local\\Strata</small></div><button class="st-btn st-btn--sm">Change</button></div>
+    <p class="mock-note">About 310 MB. Your models and chats are kept somewhere else and are never removed by an update.</p></div>
+    <footer class="onboard-footer"><button class="st-btn st-btn--ghost">Back</button><span></span><button class="st-btn st-btn--primary">Install</button></footer>`,
+  installing: theme => `<header class="onboard-header"><span class="mock-logo">${logo(theme)}</span></header>
+    <div class="mock-body"><h2 class="mock-title">Installing Strata…</h2><p class="mock-sub">Copying the app and its engine room. You can keep working meanwhile.</p>
+    <div class="onboard-progress" style="--p:62%"><progress max="100" value="62"></progress></div>
+    <div class="onboard-progress-meta"><span>62% · 190 / 310 MB</span><div class="onboard-progress-actions"><span>About 1 min left</span><button>Cancel</button></div></div></div>
+    <footer class="onboard-footer"><span></span><span class="mock-hint">Next: choose your first model inside Strata.</span><button class="st-btn st-btn--primary" disabled>Installing…</button></footer>`,
+  done: theme => `<header class="onboard-header"><span class="mock-logo">${logo(theme)}</span></header>
+    <div class="onboard-welcome-copy"><h1>Strata is ready.</h1><p>Open it to pick your first model. Strata downloads it for you and gets it ready.</p></div>
+    <footer class="onboard-footer onboard-footer--welcome"><button class="st-btn st-btn--primary">Open Strata</button><small>A shortcut was added to your Start menu and desktop.</small></footer>`,
+};
+
+const page = (name, theme) => `<!doctype html><html data-theme="${theme}"><head><meta charset="utf-8"><style>${css}
+body{background:${theme === 'dark' ? '#0b0d0e' : '#e9edef'};margin:0;display:grid;place-items:center;min-height:100vh}
+.mock-window{width:720px;border-radius:14px;overflow:hidden;background:var(--st-surface,#fff);border:1px solid var(--st-line,#dde);box-shadow:0 30px 80px #0003}
+.mock-titlebar{height:34px;display:flex;align-items:center;justify-content:space-between;padding:0 14px;font-size:12px;color:var(--st-ink-muted);background:var(--st-surface-2,#f3f5f6);border-bottom:1px solid var(--st-line-soft,#e6e9eb)}
+.mock-logo svg{height:22px;width:auto;display:block}
+.mock-body{padding:8px 36px 28px}.mock-title{font-size:28px;margin:16px 0 8px}.mock-sub{color:var(--st-ink-muted);margin:0 0 22px;line-height:1.6}
+.mock-note{color:var(--st-ink-muted);font-size:12px;margin-top:16px;line-height:1.6}.mock-hint{font-size:12px;color:var(--st-ink-muted)}
+.onboard-progress progress{width:100%}
+.guided-onboarding{min-height:430px;display:flex;flex-direction:column}.onboard-footer{margin-top:auto}
+</style></head><body><div class="mock-window"><div class="mock-titlebar"><span>Strata setup</span><span>–  ☐  ✕</span></div>
+<div class="setup guided-onboarding" data-step="${name === 'welcome' || name === 'done' ? 1 : 2}">${screens[name](theme)}</div></div></body></html>`;
+
+const browser = await chromium.launch({ executablePath: CHROME, headless: true });
+const written = [];
+for (const theme of ['light', 'dark']) {
+  for (const name of Object.keys(screens)) {
+    const tab = await browser.newPage({ viewport: { width: 860, height: 620 }, deviceScaleFactor: 1 });
+    await tab.setContent(page(name, theme));
+    await tab.waitForTimeout(250);
+    const file = join(out, `${name}-${theme}.png`);
+    await tab.screenshot({ path: file });
+    written.push(file);
+    await tab.close();
+  }
+}
+await browser.close();
+console.log(written.join('\n'));
@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+/**
+ * "Use your own GGUF" end to end on a box, through the installed app layout (packaged host + bundled Control + a real engine component):
+ *   preview a folder of a supported model, preview an unsupported GGUF (must be refused in plain terms), prepare the supported one
+ *   (pack, from the folder, nothing copied), load it, get a chat answer, unload, shut down, and check nothing is left running.
+ *
+ *   node local-gguf-e2e.mjs --root /data/ui4-e2e --good /data/141-gyro/models/IQ2_XS --bad /data/ui4-e2e/bad [--context 8192] [--backend cuda|metal]
+ *   (the app folder is <root>/app: node/, host/, control/ ...; <root>/components gets the engine, from <root>/app/engine-bundle when the app carries one)
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]]] : acc), []));
+const root = resolve(args.root);
+const good = args.good, bad = args.bad;
+const context = Number(args.context ?? 8192);
+const app = join(root, 'app');
+const dirs = { components: join(root, 'components'), install: join(root, 'install'), profiles: join(root, 'profiles'), runtime: join(root, 'runtime'), home: join(root, 'home'), xdg: join(root, 'xdg'), appdata: join(root, 'appdata') };
+for (const d of [dirs.install, dirs.home, dirs.xdg, dirs.appdata]) mkdirSync(d, { recursive: true });
+const delay = ms => new Promise(r => setTimeout(r, ms));
+const steps = [];
+let failed = false;
+const record = (name, ok, detail = '') => { steps.push({ name, ok: !!ok, detail: String(detail).slice(0, 400) }); console.log(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail ? '  ' + String(detail).slice(0, 300) : ''}`); if (!ok) failed = true; };
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+
+const env = { ...process.env, STRATA_COMPONENTS_DIR: dirs.components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime, STRATA_INSTALL_DIR: dirs.install, STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(root, 'Strata-data'), STRATA_ENGINE_BACKEND: args.backend ?? 'cuda', XDG_CONFIG_HOME: dirs.xdg, APPDATA: dirs.appdata, PYTHONDONTWRITEBYTECODE: '1' };
+delete env.STRATA_API_KEY;
+const port = await freePort();
+const base = `http://127.0.0.1:${port}`;
+const host = spawn(join(app, 'node', 'node'), [join(app, 'host', 'server', 'index.mjs')], { cwd: join(app, 'host'), stdio: ['ignore', 'pipe', 'pipe'], detached: false,
+  env: { ...env, STRATA_PORT: String(port), STRATA_DIST: join(app, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1', STRATA_EXIT_WITH_PARENT: '1',
+    STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()), STRATA_WORKSPACE: join(root, 'workspace') } });
+mkdirSync(join(root, 'workspace'), { recursive: true });
+let hostLog = ''; host.stdout.on('data', c => { hostLog += c; }); host.stderr.on('data', c => { hostLog += c; });
+const call = async (path, method = 'GET', body) => { const r = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) }); return { status: r.status, body: await r.json().catch(() => null) }; };
+async function waitJob(id, seconds) {
+  const until = Date.now() + seconds * 1000;
+  let last = '';
+  while (Date.now() < until) {
+    const state = (await call('/api/native')).body;
+    const job = state.jobs.find(j => j.id === id);
+    if (job && job.state !== 'running') return { job, state };
+    if (job && job.summary !== last) { last = job.summary; console.log('     ...', String(job.summary).slice(0, 140)); }
+    await delay(2000);
+  }
+  throw new Error('operation did not finish in time');
+}
+const engineProcs = () => spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => l.includes(join(dirs.components, 'engine')) && /\/strata( |$)/.test(l));
+
+async function main() {
+  let up = false;
+  for (let i = 0; i < 200 && !up; i++) { try { up = (await fetch(base + '/api/health')).ok; } catch { await delay(150); } }
+  record('host healthy', up, up ? base : hostLog.slice(-500));
+  if (!up) return;
+  let status = (await call('/api/control/status')).body;
+  for (let i = 0; i < 180 && status?.engineSetup; i++) { await delay(1000); status = (await call('/api/control/status')).body; }   // the engine that came with the app is copied on the first start
+  record('Control status: bundled, engine usable', status?.engine?.usable === true, `engine=${status?.engine?.engine?.version} ${status?.engine?.notice ?? ''}`);
+  await call('/api/native?refresh=1');
+
+  // ---- the unsupported GGUF: a plain refusal
+  const badPreview = await call('/api/native/local/preview', 'POST', { path: bad });
+  const badIssues = badPreview.body?.preview?.issues ?? badPreview.body?.issues ?? [];
+  const badStatus = badPreview.body?.preview?.file_set_status;
+  console.log('     bad preview:', badPreview.status, JSON.stringify(badPreview.body).slice(0, 400));
+  record('an unsupported GGUF is refused, nothing adopted', badPreview.status === 200 ? (badStatus !== 'plausible' || !badPreview.body.preview.candidate_selection) : badPreview.status >= 400, `status=${badPreview.status}; file_set_status=${badStatus}; issues=${JSON.stringify(badIssues)}`);
+
+  // ---- the supported folder
+  const goodPreview = await call('/api/native/local/preview', 'POST', { path: good });
+  const selection = goodPreview.body?.preview?.candidate_selection;
+  console.log('     good preview:', JSON.stringify(goodPreview.body).slice(0, 500));
+  record('a folder of a supported model is recognised', goodPreview.status === 200 && goodPreview.body?.preview?.file_set_status === 'plausible' && !!selection, `family=${selection?.family}; model=${selection?.model}; files=${goodPreview.body?.preview?.file_count}`);
+  if (!selection || args.only === 'preview') return;
+
+  // ---- prepare (what the page's button does): install from the folder, nothing copied or downloaded
+  const native0 = (await call('/api/native?refresh=1')).body;
+  const catalogSize = native0.catalog?.families?.find(f => f.family === selection.family)?.sizes.find(s => s.model === selection.model);
+  record('the catalog lists the recognised version', !!catalogSize, catalogSize ? `id=${catalogSize.id}` : `no ${selection.family}/${selection.model} in the catalog`);
+  const started = await call('/api/native/operations', 'POST', { kind: 'install', args: { family: selection.family, model: selection.model, gguf_dir: good, context, vision: 'no' } });
+  record('prepare starts', started.status < 300 && !!started.body?.id, `status=${started.status} ${JSON.stringify(started.body).slice(0, 200)}`);
+  if (!started.body?.id) return;
+  const prepared = await waitJob(started.body.id, 3600);
+  record('prepare finishes', prepared.job.state === 'done', `${prepared.job.state}: ${prepared.job.error ?? prepared.job.summary}`);
+  if (prepared.job.state !== 'done') return;
+  const native1 = (await call('/api/native?refresh=1')).body;
+  const modelId = catalogSize?.id ?? `${selection.family === 'qwen' ? '' : selection.family + '-'}${String(selection.model).toLowerCase()}`;
+  const entry = native1.installed?.models?.find(m => m.model === modelId);
+  record('the model is ready and points at the folder, not a copy', entry?.ready === true, `model=${modelId}; ready=${entry?.ready}; dataFolder=${entry?.dataFolder}`);
+  if (!entry?.ready) return;
+
+  // ---- load
+  const load = await call('/api/native/operations', 'POST', { kind: 'load', args: { model: modelId } });
+  const loaded = await waitJob(load.body.id, 1800);
+  const instance = loaded.state.instances[0];
+  record('load starts the engine from the component folder', loaded.job.state === 'done' && instance?.status === 'ready', `job=${loaded.job.state} ${loaded.job.error ?? ''}; instance=${instance?.status}`);
+  if (instance?.status !== 'ready') return;
+  record('one engine process is running', engineProcs().length === 1, engineProcs().map(l => l.trim().slice(0, 140)).join(' | '));
+
+  // ---- a chat answer, checked
+  const chat = await fetch(base + '/api/chat/stream', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ sessionId: 'e2e-chat', message: 'Reply with exactly one word: pong', history: [], nativeModelId: instance.id, thinking: 'Off', agent: false, workspaceId: null }) });
+  let text = '', done = null;
+  for await (const chunk of chat.body) {
+    for (const line of Buffer.from(chunk).toString('utf8').split('\n')) {
+      if (!line.trim()) continue;
+      try { const f = JSON.parse(line); if (f.type === 'delta') text += f.text ?? ''; if (f.type === 'done') done = f; if (f.type === 'error') text += ` [error: ${f.message}]`; } catch { /* partial line */ }
+    }
+  }
+  record('the model answers through the app (the answer text is checked)', chat.status === 200 && /pong/i.test(text), `status=${chat.status}; answer=${JSON.stringify(text.slice(0, 120))}; tokensOut=${done?.tokensOut}; tps=${done?.tps}`);
+
+  // ---- unload, shutdown, nothing left
+  const unload = await call(`/api/native/instances/${instance.id}/unload`, 'POST');
+  await delay(3000);
+  record('unload stops the engine', unload.status < 300 && engineProcs().length === 0, `status=${unload.status}; engines left=${engineProcs().length}`);
+}
+
+try { await main(); } catch (e) { record('the flow', false, e?.stack ?? e); }
+host.kill();
+for (let i = 0; i < 100 && host.exitCode === null; i++) await delay(100);
+if (host.exitCode === null) host.kill('SIGKILL');
+await delay(2000);
+const left = spawnSync('ps', ['-eo', 'pid,args'], { encoding: 'utf8' }).stdout.split('\n').filter(l => (l.includes(dirs.install) || l.includes(join(app, 'host'))) && !l.includes('ps -eo'));
+record('nothing of this run is left running', left.length === 0, left.join(' | ').slice(0, 300));
+writeFileSync(join(root, 'e2e-result.json'), JSON.stringify({ steps, hostLogTail: hostLog.slice(-2000) }, null, 1));
+console.log(failed ? 'FAILED' : 'ALL OK');
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+# Build the Strata DMG without a Finder session.
+#
+# Tauri's default DMG step runs an AppleScript that asks Finder to arrange the window (icon
+# positions, background). Finder AppleEvents time out in a non-GUI or sandboxed context — observed
+# here as `Finder got an error: AppleEvent timed out. (-1712)` — so the default path cannot be
+# relied on for an automated build. The upstream `create-dmg` script already supports exactly this
+# case via `--skip-jenkins`, which produces a plain, correct DMG with the app and the Applications
+# drop link and no cosmetic arrangement.
+#
+# Usage: scripts/make-dmg.sh [output.dmg]
+set -euo pipefail
+
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+DESKTOP="$(cd "$HERE/.." && pwd)"
+BUNDLE="$DESKTOP/src-tauri/target/release/bundle"
+APP="$BUNDLE/macos/Strata.app"
+VERSION="$(grep -m1 '^version = ' "$DESKTOP/src-tauri/Cargo.toml" | cut -d'"' -f2)"   # the one place the app version is written
+OUT="${1:-$BUNDLE/dmg/Strata_${VERSION}_aarch64.dmg}"
+
+if [ ! -d "$APP" ]; then
+  echo "error: $APP does not exist; run 'cargo tauri build --bundles app' first" >&2
+  exit 1
+fi
+
+WORK="$(mktemp -d -t strata-dmg)"
+trap 'rm -rf "$WORK"' EXIT
+
+# A staging folder is what create-dmg copies into the image: the app, and nothing else.
+#
+# The Applications drop link is created by `--app-drop-link` below. Adding one here as well makes
+# create-dmg fail with "File exists", because it links into the volume it is assembling.
+mkdir -p "$WORK/stage"
+cp -R "$APP" "$WORK/stage/"
+
+# Reuse Tauri's vendored create-dmg if the bundler left it behind, otherwise take it from the
+# bundle cache. Building it yourself is not necessary and not expected.
+SCRIPT="$BUNDLE/dmg/bundle_dmg.sh"
+if [ ! -x "$SCRIPT" ]; then
+  echo "error: $SCRIPT not found; run 'cargo tauri build --bundles dmg' once to vendor it" >&2
+  exit 1
+fi
+
+mkdir -p "$(dirname "$OUT")"
+rm -f "$OUT"
+
+# --skip-jenkins: no Finder AppleScript. Everything else is the same code path Tauri uses.
+"$SCRIPT" \
+  --volname "Strata $VERSION" \
+  --volicon "$BUNDLE/macos/Strata.app/Contents/Resources/Strata.icns" \
+  --app-drop-link 400 200 \
+  --skip-jenkins \
+  --no-internet-enable \
+  "$OUT" "$WORK/stage"
+
+echo
+echo "built: $OUT"
+ls -lh "$OUT" | awk '{print "size:  " $5}'
+shasum -a 256 "$OUT"
@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * The app and installer icon, refined from the existing Strata mark (apps/host/public/brand/strata-mark-*.svg and the current
+ * icons/icon.png): the same three rounded bars on the same dark tile, in the same colours. Nothing is redrawn. What changes is
+ * how it is cut for small sizes: at 16-48 px the bars are snapped to whole pixels and made a little bolder and wider so they
+ * stay crisp instead of blurring; from 64 px up the geometry is the mark's own proportions.
+ *
+ *   node apps/desktop/scripts/make-icons.mjs [--out <folder>]    writes icon-<size>.png for every size and icon.ico
+ */
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]]] : acc), []));
+const here = dirname(fileURLToPath(import.meta.url));
+const host = resolve(here, '../../host');
+const out = resolve(args.out ?? join(here, '../src-tauri/icons'));
+mkdirSync(out, { recursive: true });
+const { chromium } = await import(pathToFileURL(join(host, 'node_modules/playwright-core/index.mjs')).href).catch(() => import('playwright-core'));
+const CHROME = process.env.CHROME ?? ['C:/Program Files/Google/Chrome/Application/chrome.exe', '/usr/bin/google-chrome'].find(existsSync);
+
+const TILE = '#161a1d', LIGHT = '#eef1f3', GREEN = '#34d399';   // the colours of the current icon.png
+
+/** Integer geometry for the small sizes: bars on whole pixels, centred. Returns [{x,y,w,h,fill}]. */
+function hinted(size) {
+  const bar = Math.max(2, Math.round(size * 0.14)), gap = Math.max(2, Math.round(size * 0.1)), mid = bar + 1;
+  const total = 2 * bar + mid + 2 * gap, top = Math.floor((size - total) / 2);
+  const even = w => (w % 2 === size % 2 ? w : w + 1);
+  const wide = even(Math.round(size * 0.5)), long = even(Math.round(size * 0.76));
+  return [
+    { x: (size - wide) / 2, y: top, w: wide, h: bar, fill: LIGHT },
+    { x: (size - long) / 2, y: top + bar + gap, w: long, h: mid, fill: GREEN },
+    { x: (size - wide) / 2, y: top + bar + gap + mid + gap, w: wide, h: bar, fill: LIGHT },
+  ];
+}
+/** The mark's own proportions (from icon.png at 512): bars 34% / 50% / 34% wide, 9% high, on a tile with 21.5% corners. */
+function proportional(size) {
+  const k = size / 512;
+  return [
+    { x: 170 * k, y: 156 * k, w: 173 * k, h: 46 * k, fill: LIGHT },
+    { x: 128 * k, y: 232 * k, w: 256 * k, h: 48 * k, fill: GREEN },
+    { x: 170 * k, y: 309 * k, w: 173 * k, h: 46 * k, fill: LIGHT },
+  ];
+}
+function svg(size) {
+  const small = size <= 48;
+  const bars = (small ? hinted(size) : proportional(size));
+  const radius = small ? Math.round(size * 0.22) : size * 0.215;
+  const rects = bars.map(b => `<rect x="${b.x}" y="${b.y}" width="${b.w}" height="${b.h}" rx="${small ? Math.min(b.h / 2, 1.5 + size / 32) : b.h / 2}" fill="${b.fill}"${small ? ' shape-rendering="crispEdges"' : ''}/>`).join('');
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${size}" height="${size}" viewBox="0 0 ${size} ${size}"><rect width="${size}" height="${size}" rx="${radius}" fill="${TILE}"/>${rects}</svg>`;
+}
+
+const SIZES = [16, 20, 24, 32, 40, 48, 64, 96, 128, 256, 512, 1024];
+const browser = await chromium.launch({ executablePath: CHROME, headless: true });
+const png = {};
+for (const size of SIZES) {
+  const page = await browser.newPage({ viewport: { width: size, height: size }, deviceScaleFactor: 1 });
+  await page.setContent(`<!doctype html><body style="margin:0;background:transparent">${svg(size)}</body>`);
+  png[size] = await page.screenshot({ omitBackground: true, clip: { x: 0, y: 0, width: size, height: size } });
+  await page.close();
+  writeFileSync(join(out, `icon-${size}.png`), png[size]);
+}
+await browser.close();
+
+// The .ico: one PNG image per size (16-256), the sizes Windows asks for at 100-250% scaling.
+const ICO = [16, 20, 24, 32, 40, 48, 64, 96, 128, 256];
+const head = Buffer.alloc(6); head.writeUInt16LE(0, 0); head.writeUInt16LE(1, 2); head.writeUInt16LE(ICO.length, 4);
+let offset = 6 + 16 * ICO.length;
+const entries = [], blobs = [];
+for (const size of ICO) {
+  const data = png[size], e = Buffer.alloc(16);
+  e.writeUInt8(size === 256 ? 0 : size, 0); e.writeUInt8(size === 256 ? 0 : size, 1); e.writeUInt8(0, 2); e.writeUInt8(0, 3);
+  e.writeUInt16LE(1, 4); e.writeUInt16LE(32, 6); e.writeUInt32LE(data.length, 8); e.writeUInt32LE(offset, 12);
+  offset += data.length; entries.push(e); blobs.push(data);
+}
+writeFileSync(join(out, 'icon.ico'), Buffer.concat([head, ...entries, ...blobs]));
+writeFileSync(join(out, 'icon.png'), png[512]);
+console.log('icons in', out, ICO.join(','));
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+/**
+ * The installer's pictures, drawn from the app's own design: the light surface and ink colours of the app (src/styles tokens), the
+ * brand lockup and mark files, GT Walsheim Bold for the words (baked into the pictures, because NSIS cannot use a web font).
+ *
+ *   node apps/desktop/scripts/make-installer-images.mjs [--out <folder>] [--preview <folder>]
+ *
+ * Writes sidebar.bmp (164x314, the welcome and finish pages) and header.bmp (150x57, the other pages) as 24-bit BMPs, and with
+ * --preview the same as PNGs at 3x.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]]] : acc), []));
+const here = dirname(fileURLToPath(import.meta.url));
+const host = resolve(here, '../../host');
+const out = resolve(args.out ?? join(here, '../src-tauri/nsis'));
+mkdirSync(out, { recursive: true });
+const { chromium } = await import(pathToFileURL(join(host, 'node_modules/playwright-core/index.mjs')).href).catch(() => import('playwright-core'));
+const CHROME = process.env.CHROME ?? ['C:/Program Files/Google/Chrome/Application/chrome.exe', '/usr/bin/google-chrome'].find(existsSync);
+const font = pathToFileURL(join(host, 'public/fonts/GTWalsheimPro-Bold.woff2')).href;
+const fontMedium = pathToFileURL(join(host, 'public/fonts/GTWalsheimPro-Medium.woff2')).href;
+const lockup = readFileSync(join(host, 'public/brand/strata-lockup-light.svg'), 'utf8');
+const mark = readFileSync(join(host, 'public/brand/strata-mark-light.svg'), 'utf8');
+
+// the app's light tokens
+const SURFACE = '#f9fafb', INK = '#171b1e', MUTED = '#5b646b', ACCENT = '#10b981', LINE = '#e3e8ea';
+const css = `@font-face{font-family:GT;font-weight:700;src:url(${font})}@font-face{font-family:GT;font-weight:500;src:url(${fontMedium})}
+*{box-sizing:border-box}body{margin:0;font-family:GT,'Segoe UI',sans-serif;color:${INK};background:${SURFACE}}`;
+
+const pages = {
+  sidebar: { w: 164, h: 314, html: `<div style="width:164px;height:314px;padding:22px 18px;display:flex;flex-direction:column;background:linear-gradient(180deg,#f9fafb 0%,#eef6f2 100%);border-right:1px solid ${LINE}">
+    <div style="height:26px">${lockup.replace('<svg', '<svg style="height:26px;width:auto;display:block"')}</div>
+    <div style="margin-top:auto">
+      <div style="font-weight:700;font-size:22px;line-height:1.12;letter-spacing:-.01em">State of<br>the art.<br>At home.</div>
+      <div style="margin-top:10px;font-weight:500;font-size:11px;line-height:1.5;color:${MUTED}">AI on your own computer.<br>Private. Fast. Easy.</div>
+      <div style="margin-top:16px;height:3px;width:34px;border-radius:2px;background:${ACCENT}"></div>
+    </div></div>` },
+  header: { w: 150, h: 57, html: `<div style="width:150px;height:57px;display:flex;align-items:center;justify-content:flex-end;padding-right:12px;background:${SURFACE}">${lockup.replace('<svg', '<svg style="height:22px;width:auto;display:block"')}</div>` },
+};
+
+const browser = await chromium.launch({ executablePath: CHROME, headless: true });
+const work = join(tmpdir(), 'strata-installer-images'); mkdirSync(work, { recursive: true });
+for (const [name, page] of Object.entries(pages)) {
+  for (const scale of [1, 3]) {
+    const file = join(work, `${name}.html`);
+    writeFileSync(file, `<!doctype html><meta charset="utf-8"><style>${css}</style><body>${page.html}</body>`);
+    const tab = await browser.newPage({ viewport: { width: page.w, height: page.h }, deviceScaleFactor: scale });
+    await tab.goto(pathToFileURL(file).href);
+    await tab.evaluate(() => document.fonts.ready);
+    await tab.waitForTimeout(200);
+    const png = join(work, `${name}@${scale}.png`);
+    await tab.screenshot({ path: png, clip: { x: 0, y: 0, width: page.w, height: page.h } });
+    await tab.close();
+    if (scale === 3 && args.preview) { mkdirSync(resolve(args.preview), { recursive: true }); writeFileSync(join(resolve(args.preview), `${name}.png`), readFileSync(png)); }
+  }
+}
+await browser.close();
+// 24-bit BMP, the format NSIS wants: render at 3x, shrink with a good filter
+const py = `import sys\nfrom PIL import Image\nfor name in ('sidebar','header'):\n    im = Image.open(sys.argv[1] + '/' + name + '@3.png').convert('RGB')\n    w, h = im.width // 3, im.height // 3\n    im.resize((w, h), Image.LANCZOS).save(sys.argv[2] + '/' + name + '.bmp', 'BMP')\n`;
+const done = spawnSync('python', ['-c', py, work, out], { encoding: 'utf8' });
+if (done.status !== 0) { console.error(done.stderr); process.exit(1); }
+console.log('wrote', join(out, 'sidebar.bmp'), join(out, 'header.bmp'));
@@ -0,0 +1,85 @@
+#!/usr/bin/env bash
+# Write a tester's README with the checksums and sizes of the files it names, computed from the files themselves.
+#
+#   apps/desktop/scripts/make-tester-readme.sh <template> <out.txt> --appimage <file name> --files-dir <dir> [--files-dir <dir> ...]
+#
+# Why: a README that carries a hand-pasted sha256 goes stale the moment the file is rebuilt (the Ubuntu 26.04 tester compared the file
+# with the old build's hash). The template holds placeholders instead, and this script fills them from the real files:
+#   @APPIMAGE@            the AppImage's file name
+#   @APP_VERSION@         the app version, read from apps/desktop/src-tauri/Cargo.toml
+#   @SHA256:<name>@       sha256 of the file <name> found in one of the --files-dir folders
+#   @SIZE_GB:<name>@      its size in GB with one decimal
+#   @INCLUDE:<file>@      (alone on a line) the contents of <file> from the template's folder, with the same placeholders
+# It refuses to write the README when a named file is missing or a placeholder is left over, so a stale or empty hash cannot ship.
+# The same check is done by `--verify <readme> --files-dir <dir>`: every "<64 hex>  <name>" or "sha256 <64 hex>" pair that names a file
+# present in the folders must match that file.
+set -euo pipefail
+
+usage() { echo "usage: $0 <template> <out.txt> --appimage <name> --files-dir <dir> [--files-dir <dir> ...]" >&2; echo "       $0 --verify <readme> --files-dir <dir> [...]" >&2; exit 2; }
+
+VERIFY=""; TEMPLATE=""; OUT=""; APPIMAGE=""; DIRS=()
+if [ "${1:-}" = "--verify" ]; then VERIFY="${2:?readme}"; shift 2; else TEMPLATE="${1:?template}"; OUT="${2:?out}"; shift 2 || usage; fi
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --appimage) APPIMAGE="$2"; shift 2 ;;
+    --files-dir) DIRS+=("$2"); shift 2 ;;
+    *) usage ;;
+  esac
+done
+[ ${#DIRS[@]} -gt 0 ] || usage
+
+find_file() { local d; for d in "${DIRS[@]}"; do [ -f "$d/$1" ] && { echo "$d/$1"; return 0; }; done; return 1; }
+sha_of() { sha256sum "$1" | awk '{print $1}'; }
+size_gb() { awk -v b="$(stat -c %s "$1" 2>/dev/null || stat -f %z "$1")" 'BEGIN{printf "%.1f", b/1000000000}'; }
+
+if [ -n "$VERIFY" ]; then
+  # every checksum in the README must be the checksum of a file that is here, and a line that names a file and carries a checksum must carry that file's checksum
+  hashes=""; bad=0; seen=0
+  for d in "${DIRS[@]}"; do for f in "$d"/*; do [ -f "$f" ] && grep -qF "$(basename "$f")" "$VERIFY" && hashes="$hashes $(sha_of "$f")"; done; done   # only files the README names are hashed (a folder may hold big unrelated files)
+  readme_hashes="$(grep -Eo '[0-9a-f]{64}' "$VERIFY" | sort -u || true)"
+  for h in $readme_hashes; do
+    seen=$((seen + 1))
+    case " $hashes " in *" $h "*) ;; *) echo "STALE: the README lists $h, which is the checksum of no file in: ${DIRS[*]}" >&2; bad=$((bad + 1)) ;; esac
+  done
+  for d in "${DIRS[@]}"; do for f in "$d"/*; do
+    [ -f "$f" ] || continue
+    grep -qF "$(basename "$f")" "$VERIFY" || continue
+    # a line that names this file AND carries a checksum must carry this file's checksum (a sentence that merely mentions the file is fine)
+    line_hash="$(grep -F "$(basename "$f")" "$VERIFY" | grep -Eo '[0-9a-f]{64}' | head -1 || true)"
+    if [ -n "$line_hash" ] && [ "$line_hash" != "$(sha_of "$f")" ]; then
+      echo "STALE: $(basename "$f") is $(sha_of "$f"), the README says $line_hash" >&2; bad=$((bad + 1))
+    fi
+  done; done
+  echo "$seen checksum(s) in the README checked, $bad stale"
+  [ "$bad" = 0 ] && [ "$seen" -gt 0 ]
+  exit
+fi
+
+[ -n "$APPIMAGE" ] || usage
+TDIR="$(cd "$(dirname "$TEMPLATE")" && pwd)"
+# the app version has one source (the same file Tauri and the shell use)
+APP_VERSION="$(grep -m1 '^version = ' "$TDIR/../src-tauri/Cargo.toml" | cut -d'"' -f2)"
+[ -n "$APP_VERSION" ] || { echo "make-tester-readme: no version in $TDIR/../src-tauri/Cargo.toml" >&2; exit 1; }
+TMP="$(mktemp)"; trap 'rm -f "$TMP" "$TMP.2"' EXIT
+# includes first (one level), then the placeholders
+while IFS= read -r line || [ -n "$line" ]; do
+  if [[ "$line" =~ ^@INCLUDE:([^@]+)@$ ]]; then tr -d '\r' < "$TDIR/${BASH_REMATCH[1]}"; else printf '%s\n' "$line"; fi
+done < <(tr -d '\r' < "$TEMPLATE") | sed "s|@APPIMAGE@|$APPIMAGE|g; s|@APP_VERSION@|$APP_VERSION|g" > "$TMP"
+
+# @SHA256:name@ and @SIZE_GB:name@
+while IFS= read -r token; do
+  kind="${token#@}"; kind="${kind%%:*}"; name="${token#@*:}"; name="${name%@}"
+  f="$(find_file "$name")" || { echo "make-tester-readme: no file named $name in: ${DIRS[*]} (a README must not carry a hash it did not compute)" >&2; exit 1; }
+  case "$kind" in
+    SHA256) value="$(sha_of "$f")" ;;
+    SIZE_GB) value="$(size_gb "$f")" ;;
+    *) echo "make-tester-readme: unknown placeholder $token" >&2; exit 1 ;;
+  esac
+  # replace every occurrence of this exact token (plain text, no pattern characters)
+  text="$(cat "$TMP"; printf x)"; text="${text%x}"
+  printf '%s' "${text//"$token"/$value}" > "$TMP"
+done < <(grep -Eo '@(SHA256|SIZE_GB):[^@ ]+@' "$TMP" | sort -u)
+
+if grep -Eq '@[A-Z0-9_]+[:@]' "$TMP"; then echo "make-tester-readme: placeholders left over:" >&2; grep -En '@[A-Z0-9_]+[:@]' "$TMP" >&2; exit 1; fi
+cp "$TMP" "$OUT"
+echo "wrote $OUT"
@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * Attached pictures reaching a model, end to end on a test box, through the installed app layout (packaged host + bundled Control + an engine
+ * component that carries strata-vision):
+ *   1. the model catalog marks the picture-capable models (images: true) when the picture reader is installed;
+ *   2. API models: a llama-server with a small picture model (--mmproj) is saved as a Custom model API; the host works out that it reads pictures,
+ *      and a real picture goes out as image_url and is answered. A server without a picture reader, a model set "not to read pictures", and an API
+ *      of another style each get a plain refusal (409) that says how to fix it; ticking "This model reads pictures" lets the picture through;
+ *   3. a local model (unless --skip-local): Download and prepare with Read pictures ON, load, and a picture through the app's own chat.
+ *
+ *   node pics-e2e.mjs --install <node/ host/ control/> --components <engine components> --work <scratch> --image shapes.png \
+ *   Also: --silent <url> (a server whose model list says nothing about pictures: ON by default), --agent (the same picture through the agent; needs a Harness)
+ *        --vlm http://127.0.0.1:18090/v1 --vlm-model smolvlm --text-only http://127.0.0.1:18091/v1 [--skip-local --family qwen --model IQ3_XXS --data <folder> --device cpu]
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') || all[i + 1] === undefined ? true : all[i + 1]]] : acc), []));
+for (const need of ['install', 'components', 'work', 'image']) if (!args[need]) { console.error('missing --' + need); process.exit(2); }
+const install = resolve(args.install), work = resolve(args.work), components = resolve(args.components);
+const want = String(args.match ?? args.model ?? 'IQ3_XXS').toLowerCase(), contextSize = Number(args.context ?? 32768), skipLocal = args['skip-local'] === true, device = String(args.device ?? 'cpu'), family = String(args.family ?? 'qwen'), modelId = String(args.model ?? 'IQ3_XXS');
+const node = join(install, 'node', 'node'), hostEntry = join(install, 'host', 'server', 'index.mjs');
+const dirs = { models: join(work, 'models'), profiles: join(work, 'profiles'), runtime: join(work, 'runtime'), home: join(work, 'home'), xdg: join(work, 'xdg'), appdata: join(work, 'appdata') };
+for (const d of [dirs.models, dirs.home, dirs.xdg, dirs.appdata]) mkdirSync(d, { recursive: true });
+const delay = ms => new Promise(r => setTimeout(r, ms));
+let failed = false;
+const record = (name, ok, detail = '') => { if (!ok) failed = true; console.log(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail ? '  ' + String(detail).slice(0, 600) : ''}`); };
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+const env = { ...process.env, STRATA_COMPONENTS_DIR: components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime, STRATA_INSTALL_DIR: dirs.models,
+  STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(work, 'models-unused'), APPDATA: dirs.appdata, XDG_CONFIG_HOME: dirs.xdg, PYTHONDONTWRITEBYTECODE: '1' };
+delete env.STRATA_API_KEY;
+const port = await freePort();
+const base = `http://127.0.0.1:${port}`;
+const host = spawn(node, [hostEntry], { cwd: join(install, 'host'), stdio: ['ignore', 'pipe', 'pipe'],
+  env: { ...env, STRATA_PORT: String(port), STRATA_DIST: join(install, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1',
+    STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()) } });
+let hostLog = '';
+host.stdout.on('data', c => { hostLog += c; }); host.stderr.on('data', c => { hostLog += c; });
+const call = async (path, method = 'GET', body) => {
+  const response = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: response.status, body: await response.json().catch(() => null) };
+};
+const png = 'data:image/png;base64,' + readFileSync(resolve(args.image)).toString('base64');
+const QUESTION = 'Name each shape in this picture with its colour, and read out any text.';
+
+/** One chat turn through the app's own endpoint: the plain-text answer, or the refusal (status + message). */
+async function chat(extra, message = QUESTION) {
+  const response = await fetch(base + '/api/chat/stream', { method: 'POST', headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ message, agent: false, images: [{ url: png, name: 'shapes.png' }], ...extra }) });
+  if (response.status !== 200) { const b = await response.json().catch(() => ({})); return { status: response.status, message: b.error ?? b.message ?? '' }; }
+  let text = '', error = '';
+  for (const line of (await response.text()).split('\n')) {
+    if (!line.trim()) continue;
+    let f; try { f = JSON.parse(line); } catch { continue; }
+    if (f.type === 'error') error = f.message ?? 'error';
+    else if (typeof f.text === 'string' && f.type === 'delta') text += f.text;
+  }
+  return { status: 200, text, error };
+}
+const saveApi = async (name, baseUrl, models, protocol = 'openai-chat') => {
+  const existing = (await call('/api/model-providers')).body.connections.find(c => c.name === name);
+  return (await call('/api/model-providers', 'POST', { ...(existing ? { id: existing.id } : {}), kind: 'custom', provider: null, name, baseUrl, protocol, apiKey: '', models })).body;
+};
+async function readsAfter(connectionName, id, want, seconds = 20) {
+  for (let i = 0; i < seconds * 2; i++) {
+    const c = (await call('/api/model-providers')).body.connections.find(x => x.name === connectionName);
+    const m = c?.models.find(x => x.id === id);
+    if (m && m.reads === want) return { c, m };
+    await delay(500);
+  }
+  const c = (await call('/api/model-providers')).body.connections.find(x => x.name === connectionName);
+  return { c, m: c?.models.find(x => x.id === id) };
+}
+async function waitJob(id, seconds) {
+  let last = '';
+  for (let i = 0; i < seconds * 2; i++) {
+    const state = (await call('/api/native')).body;
+    const job = state.jobs.find(j => j.id === id);
+    if (job && job.summary !== last) { last = job.summary; console.log('    ... ' + String(last).slice(0, 120)); }
+    if (job && job.state !== 'running') return { job, state };
+    await delay(500);
+  }
+  throw new Error('operation did not finish');
+}
+const names = low => /(red|blue|green|circle|square|triangle|strata|42)/.test(low);
+
+async function main() {
+  let up = false;
+  for (let i = 0; i < 200 && !up; i++) { try { up = (await fetch(base + '/api/health')).ok; } catch { /* not yet */ } if (!up) await delay(150); }
+  record('host healthy', up, up ? base : hostLog.slice(-500));
+  if (!up) return;
+
+  // ---- 1. the catalog
+  const packages = existsSync(join(components, 'engine')) ? readdirSync(join(components, 'engine')) : [];
+  const reader = packages.some(p => existsSync(join(components, 'engine', p, 'strata-vision')));
+  const native = (await call('/api/native?refresh=1')).body;
+  record('the engine component carries the picture reader and the host knows it (visionReader)', reader && native.visionReader === true, `component=${reader} host=${native.visionReader}`);
+  const rows = (native.catalog?.families ?? []).flatMap(f => (f.sizes ?? []).map(s => ({ family: f.title ?? f.family, size: s.id, images: s.images, capable: s.imagesCapable })));
+  console.log('    catalog (family / size / images / imagesCapable):');
+  for (const r of rows) console.log(`      ${String(r.family).padEnd(26)} ${String(r.size).padEnd(30)} images=${r.images} capable=${r.capable}`);
+  record('some models in the catalog read pictures', rows.some(r => r.images === true), `${rows.filter(r => r.images).length} of ${rows.length}`);
+  record('every picture-capable model reads pictures when the reader is installed', rows.every(r => r.capable === r.images), '');
+  const flash = rows.filter(r => /flash-next/i.test(`${r.family} ${r.size}`) && !/gyro|qad/i.test(`${r.family} ${r.size}`));
+  record('the Qwen3.8-Flash-Next models are marked images: true', flash.length > 0 && flash.every(r => r.images === true), flash.map(r => r.size + '=' + r.images).join(' '));
+
+  // ---- 2. API models
+  if (args.vlm) {
+  const smol = args['vlm-model'] ?? 'smolvlm';
+  await saveApi('Small picture model', args.vlm, [{ id: smol, name: 'SmolVLM' }]);
+  const found = await readsAfter('Small picture model', smol, true);
+  record('the host works out that the llama-server reads pictures (no tick needed)', found.m?.reads === true, JSON.stringify(found.m));
+  const conn = found.c;
+  const sent = await chat({ remoteModel: { connectionId: conn?.id, modelId: smol } });
+  console.log(`    answer from the API model: ${JSON.stringify((sent.text ?? sent.message ?? '').slice(0, 300))}`);
+  record('the picture goes to the API model and is answered', sent.status === 200 && !sent.error && (sent.text ?? '').trim().length > 0 && names((sent.text ?? '').toLowerCase()), `status=${sent.status} err=${sent.error ?? ''}`);
+
+  if (args['text-only']) {
+    await saveApi('Text only server', args['text-only'], [{ id: 'plain', name: 'Plain model' }]);
+    const t = await readsAfter('Text only server', 'plain', false);
+    record('a server without a picture reader is known not to read pictures', t.m?.reads === false, JSON.stringify(t.m));
+    const refused = await chat({ remoteModel: { connectionId: t.c.id, modelId: 'plain' } });
+    console.log(`    refusal: ${JSON.stringify(refused.message)}`);
+    record('a picture for it is refused in plain words that say how to fix it', refused.status === 409 && /Read pictures with this model/.test(refused.message ?? '') && /Settings/.test(refused.message ?? ''), `${refused.status}`);
+    const ticked = await saveApi('Text only server', args['text-only'], [{ id: 'plain', name: 'Plain model', vision: true }]);
+    const after = (await call('/api/model-providers')).body.connections.find(x => x.name === 'Text only server');
+    record('ticking "Read pictures with this model" is saved and makes the model read pictures', after?.models[0]?.vision === true && after?.models[0]?.reads === true, JSON.stringify(after?.models[0]));
+    const through = await chat({ remoteModel: { connectionId: after.id, modelId: 'plain' } });
+    record('with the tick the picture is sent on (the server itself decides what to do with it)', through.status === 200 && (through.error ?? '') !== '' ? /turn off/.test(through.error) : through.status === 200, `${through.status} ${through.message ?? through.error ?? ''}`);
+  }
+
+  await saveApi('Small picture model', args.vlm, [{ id: smol, name: 'SmolVLM', vision: false }]);
+  const off = await readsAfter('Small picture model', smol, false);
+  const notRead = await chat({ remoteModel: { connectionId: off.c.id, modelId: smol } });
+  record('a model switched OFF refuses pictures and says where to turn them on again', notRead.status === 409 && /not to read pictures/.test(notRead.message ?? '') && /Settings/.test(notRead.message ?? ''), `${notRead.status} ${notRead.message ?? ''}`);
+  await saveApi('Small picture model', args.vlm, [{ id: smol, name: 'SmolVLM', vision: null }]);
+
+  // unknown is ON by default: a server whose list and /props say nothing is sent the picture
+  if (args.silent) {
+    await saveApi('Silent server', args.silent, [{ id: 'quiet', name: 'Quiet model' }]);
+    const q = await readsAfter('Silent server', 'quiet', true, 8);
+    record('a server that says nothing about pictures is ON by default', q.m?.reads === true && q.m?.vision === null, JSON.stringify(q.m));
+    const sentQuiet = await chat({ remoteModel: { connectionId: q.c.id, modelId: 'quiet' } });
+    record('and the picture is sent to it (not refused)', sentQuiet.status === 200, `${sentQuiet.status} ${sentQuiet.message ?? sentQuiet.error ?? ''}`);
+  }
+  await saveApi('Other style', 'https://api.anthropic.com/v1', [{ id: 'claude-x', name: 'Claude' }], 'anthropic');
+  const other = (await call('/api/model-providers')).body.connections.find(x => x.name === 'Other style');
+  const style = await chat({ remoteModel: { connectionId: other.id, modelId: 'claude-x' } });
+  console.log(`    other style: ${JSON.stringify(style.message)}`);
+  record('an API of another style says plainly why pictures stay in the preview', style.status === 409 && /OpenAI/.test(style.message ?? ''), `${style.status}`);
+
+  }
+  if (skipLocal) return;
+
+  // ---- 3. a local model
+  const values = { family, model: modelId, context: contextSize, vision: 'yes', loadVision: device, ...(args.data ? { data_dir: resolve(args.data) } : {}) };
+  const started = await call('/api/native/operations', 'POST', { kind: 'install', args: values });
+  record('the install operation starts', started.status === 200 || started.status === 202, JSON.stringify(started.body).slice(0, 200));
+  const done = await waitJob(started.body.id, 3600);
+  record('Download and prepare finishes', done.job.state === 'done', `${done.job.state} ${done.job.error ?? done.job.summary}`);
+  const refreshed = (await call('/api/native?refresh=1')).body;
+  const model = refreshed.installed?.models?.find(m => [m.id, m.model, m.tag].some(x => String(x ?? '').toLowerCase() === want));
+  record('the model is prepared with its picture reader', !!model?.visionPrepared, JSON.stringify({ ready: model?.ready, visionPrepared: model?.visionPrepared }));
+  const load = await call('/api/native/operations', 'POST', { kind: 'load', args: { model: model?.model ?? want } });
+  const loaded = await waitJob(load.body.id, 900);
+  const instance = loaded.state.instances[0];
+  record('the model loads with the picture reader', loaded.job.state === 'done' && instance?.status === 'ready' && instance?.vision === true, `${loaded.job.state} ${loaded.job.error ?? ''} vision=${instance?.vision}`);
+  record('the model loaded with pictures ON without being asked per load (default)', instance?.vision === true, '');
+  const t0 = Date.now();
+  let local = { status: 0 };
+  for (let i = 0; i < 2 && !(local.text ?? '').trim(); i++) local = await chat({ nativeModelId: instance?.id, maxTokens: 4096 });
+  console.log(`    answer from the local model (${Math.round((Date.now() - t0) / 1000)} s): ${JSON.stringify((local.text ?? local.message ?? '').slice(0, 300))}`);
+  const low = (local.text ?? '').toLowerCase();
+  record('the local model answers about the picture (names the shapes)', local.status === 200 && /red|circle/.test(low) && /blue|square/.test(low) && /green|triangle/.test(low), `status=${local.status} err=${local.error ?? ''}`);
+  record('the local model reads STRATA 42', low.includes('42'));
+  // the same picture through the agent (the Harness route must declare image input: the "does not declare image input" error of the tester)
+  if (args.agent) {   // needs a Harness beside the host (the installed layout has one; a bare test box does not)
+    const t1 = Date.now(); let a = { status: 0 };
+    for (let i = 0; i < 2 && !/red|circle|square|triangle/.test((a.text ?? '').toLowerCase()); i++) a = await chat({ nativeModelId: instance?.id, agent: true, sessionId: 'pics-agent-' + i, mode: 'plan', maxTokens: 4096 });
+    console.log(`    answer through the agent (${Math.round((Date.now() - t1) / 1000)} s): ${JSON.stringify((a.text ?? a.message ?? '').slice(0, 300))}`);
+    record('the agent route reads the picture too', a.status === 200 && /red|circle|square|triangle/.test((a.text ?? '').toLowerCase()) && !/does not declare image input/.test(a.text ?? ''), `status=${a.status} err=${a.error ?? ''}`);
+  }
+  // OFF: loading with Read pictures off refuses a picture in plain words and says what to do
+  await call(`/api/native/instances/${instance?.id}/unload`, 'POST', {});
+  const loadOff = await call('/api/native/operations', 'POST', { kind: 'load', args: { model: model?.model ?? want, vision: 'no' } });
+  const loadedOff = await waitJob(loadOff.body.id, 900);
+  const off2 = loadedOff.state.instances[0];
+  record('loaded with Read pictures OFF', loadedOff.job.state === 'done' && off2?.vision === false, `${loadedOff.job.state} vision=${off2?.vision}`);
+  const refusedLocal = await chat({ nativeModelId: off2?.id, maxTokens: 64 });
+  console.log(`    refusal: ${JSON.stringify(refusedLocal.message)}`);
+  record('a picture for the OFF model is refused with a next step', refusedLocal.status === 409 && /Read pictures/.test(refusedLocal.message ?? '') && /Models/.test(refusedLocal.message ?? ''), `${refusedLocal.status}`);
+  const unloaded = await call(`/api/native/instances/${off2?.id}/unload`, 'POST', {});
+  record('unload', unloaded.status === 200, unloaded.status);
+}
+try { await main(); } catch (e) { record('run', false, e.stack ?? e); }
+host.kill();
+await delay(1500);
+console.log(failed ? 'PICS-E2E FAIL' : 'PICS-E2E PASS');
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# Put the bundled payloads back to the bytes they were staged with, inside a finished AppImage.
+#
+#   apps/desktop/scripts/repack-appimage.sh <in.AppImage> <out.AppImage> [--resources <src-tauri/resources>] [--check]
+#
+# Why: Tauri hands the AppDir to linuxdeploy, which treats every ELF file under usr/lib as a library to fix up: it rewrites the RPATH of
+# the engine (strata, libstrata_kq.so, libcudart), of the bundled Python and Node and of the Harness's native modules. The files then no
+# longer match the SHA-256 and size their manifests list (engine-component.json), so the host refuses the bundled engine, and the
+# installer's own integrity promise ("what we staged is what runs") is broken. This script unpacks the AppImage, copies the staged
+# folders (control, harness, node, engine-bundle) over the AppDir byte for byte, and packs it again with the same runtime.
+#
+# --check does not write anything: it lists every engine-bundle file whose bytes differ from the manifest in the AppImage.
+set -euo pipefail
+
+IN="$(realpath "${1:?in.AppImage}")"; OUT="${2:-}"
+RES="$(cd "$(dirname "${BASH_SOURCE[0]}")/../src-tauri/resources" && pwd)"
+CHECK=0
+shift 2 || true
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --resources) RES="$(cd "$2" && pwd)"; shift 2 ;;
+    --check) CHECK=1; shift ;;
+    *) echo "unknown option $1" >&2; exit 2 ;;
+  esac
+done
+
+OFFSET="$("$IN" --appimage-offset)"
+WORK="$(mktemp -d -t strata-repack.XXXXXX)"
+trap 'rm -rf "$WORK"' EXIT
+unsquashfs -no-progress -o "$OFFSET" -d "$WORK/AppDir" "$IN" >/dev/null
+# the product folder under usr/lib (Tauri names it after productName)
+LIB="$(find "$WORK/AppDir/usr/lib" -maxdepth 2 -type d -name engine-bundle -printf '%h\n' | head -1)"
+[ -n "$LIB" ] || LIB="$(find "$WORK/AppDir/usr/lib" -maxdepth 2 -type d -name control -printf '%h\n' | head -1)"
+[ -n "$LIB" ] || { echo "no Strata resource folder in the AppImage" >&2; exit 1; }
+
+if [ "$CHECK" = 1 ]; then
+  bad=0
+  while IFS= read -r f; do
+    rel="${f#$RES/}"
+    if ! cmp -s "$f" "$LIB/$rel"; then echo "differs: $rel"; bad=$((bad + 1)); fi
+  done < <(find "$RES/engine-bundle" "$RES/node" -type f ! -name .gitignore)
+  echo "$bad file(s) differ from what was staged"
+  [ "$bad" = 0 ]
+  exit
+fi
+
+[ -n "$OUT" ] || { echo "give out.AppImage" >&2; exit 2; }
+for d in control harness node engine-bundle; do
+  [ -d "$RES/$d" ] || continue
+  rsync -aL --checksum --delete --exclude .gitignore "$RES/$d/" "$LIB/$d/"
+done
+# The launcher records the environment the AppImage was started from, before its own hooks add the AppImage's libraries and GTK/GIO
+# settings (LD_LIBRARY_PATH, GTK_*, XDG_DATA_DIRS ...). The host gives it back to every program that is not Strata's own (zenity,
+# kdialog, xdg-open, the assistant's shell): apps/host/server/external-env.mjs. Without it a system program loads the AppImage's libssl
+# and dies ("OPENSSL_3.2.0 not found"). The line goes right after `this_dir=...`, ahead of every hook.
+if ! grep -q STRATA_ORIGINAL_ENV "$WORK/AppDir/AppRun"; then
+  sed -i '/^this_dir=/a # Strata: the environment this AppImage was started from (given back to programs that are not Strata'"'"'s own)\nexport STRATA_ORIGINAL_ENV="$(env -0 | base64 -w0)"' "$WORK/AppDir/AppRun"
+  grep -q STRATA_ORIGINAL_ENV "$WORK/AppDir/AppRun" || { echo "could not add the environment record to AppRun" >&2; exit 1; }
+fi
+mksquashfs "$WORK/AppDir" "$WORK/app.squashfs" -root-owned -noappend -comp zstd -b 131072 -no-progress >/dev/null
+head -c "$OFFSET" "$IN" > "$OUT"
+cat "$WORK/app.squashfs" >> "$OUT"
+chmod +x "$OUT"
+# The checksum is computed here, from the finished file, every time: a README or a note must take it from this file
+# (apps/desktop/scripts/make-tester-readme.sh) and never from an older build.
+( cd "$(dirname "$OUT")" && sha256sum "$(basename "$OUT")" > "$(basename "$OUT").sha256" )
+echo "repacked: $OUT ($(stat -c %s "$OUT") bytes)"
+cat "$OUT.sha256"
@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Stage the Control component the installer ships: src-tauri/resources/control.
+
+    python apps/desktop/scripts/stage-control.py                       # build the terminal bundle, stage it
+    python apps/desktop/scripts/stage-control.py --archive X.zip       # stage an archive you already built
+    python apps/desktop/scripts/stage-control.py --wheelhouse DIR      # build with no network (wheels from DIR)
+    python apps/desktop/scripts/stage-control.py --check               # verify what is staged
+
+What lands in `control/`: the pinned CPython 3.12.15 (python-build-standalone, digest-checked), the hash-locked wheels
+(`packaging/locks/runtime-<target>-cp312.txt`, installed with --require-hashes at build time), strata_control,
+strata_cli, serve, tools/strata_tokenizer.py + gguf_reader.py, and BUNDLE.json (version, interpreter and lock digests,
+the digest of the archive it came from). It is the same bundle as the Terminal archive (packaging/package_terminal.py):
+one Python runtime-core for both products. The app then never runs pip, npm, git or a compiler to start or serve.
+
+This script is a BUILD step. It may download the interpreter and the wheels (verified); the app never does.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import zipfile
+import tarfile
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[2]
+OUT = HERE.parent / "src-tauri" / "resources" / "control"
+sys.path.insert(0, str(ROOT / "packaging"))
+import package_terminal as pt  # noqa: E402
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as stream:
+        for block in iter(lambda: stream.read(1 << 20), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def build_archive(work: Path, wheelhouse: str | None) -> Path:
+    command = [sys.executable, str(ROOT / "packaging" / "package_terminal.py"), "--out", str(work)]
+    if wheelhouse:
+        command += ["--wheelhouse", wheelhouse]
+    subprocess.run(command, check=True, cwd=str(ROOT))
+    archives = sorted(work.glob("strata-terminal-*.zip")) + sorted(work.glob("strata-terminal-*.tar.gz"))
+    if len(archives) != 1:
+        raise SystemExit(f"expected one archive in {work}, found {archives}")
+    return archives[0]
+
+
+def extract(archive: Path, destination: Path) -> Path:
+    """Unpack the archive; returns the folder that holds python/ and strata.py."""
+    scratch = destination.parent / (destination.name + ".incoming")
+    shutil.rmtree(scratch, ignore_errors=True)
+    scratch.mkdir(parents=True)
+    if archive.name.endswith(".zip"):
+        with zipfile.ZipFile(archive) as zf:
+            for member in zf.namelist():
+                target = (scratch / member).resolve()
+                if scratch.resolve() not in target.parents and target != scratch.resolve():
+                    raise SystemExit(f"unsafe member in {archive.name}: {member}")
+            zf.extractall(scratch)
+    else:
+        with tarfile.open(archive) as tf:
+            tf.extractall(scratch, filter="data")
+    (inner,) = [p for p in scratch.iterdir() if p.is_dir()]
+    return inner
+
+
+#: What the app's installer needs on top of the Terminal bundle: the model catalog, GPU probe and install job. The list and the copy
+#: live in packaging/package_terminal.py (the Terminal archive carries the same files, for `strata launch`).
+INSTALLER_FILES, INSTALLER_TOOLS, INSTALLER_DATA = pt.INSTALLER_FILES, pt.INSTALLER_TOOLS, pt.INSTALLER_DATA
+local_imports = pt.local_imports
+
+
+def add_installer(folder: Path) -> dict:
+    """Copy the installer's files from the source tree into the staged Control (after the Terminal bundle is in place)."""
+    return pt.add_installer(folder, ROOT)
+
+
+#: What the other names of the interpreter become: Tauri copies a symlink as a full copy of its target, so `python`, `python3` and
+#: `python3.12` in a bundle would be three real files (68 MB each on Linux). Only `python3.12` stays the real one.
+#: The launcher runs inside the AppImage's environment (LD_LIBRARY_PATH holds the bundled libraries), where an external program such as
+#: `dirname` can fail to start (Ubuntu 26.04's coreutils: "libsystemd.so.0: version LIBSYSTEMD_254 not found"), so it uses shell built-ins
+#: only. The first version called `dirname`; that left the folder empty and "Control stopped" on such a computer.
+LAUNCHER = """#!/bin/sh
+# Strata: this name only starts the real interpreter beside it (the bundle keeps one copy, not one per name). Built-ins only: no dirname.
+case "$0" in */*) dir=${0%%/*} ;; *) dir=. ;; esac
+here=$(cd "$dir" && pwd)
+exec "$here/%s" "$@"
+"""
+
+
+def dedupe_python(folder: Path) -> list[str]:
+    """Make every other name of the interpreter in `python/bin` a small launcher of the real binary (Linux and macOS; Windows has one
+    python.exe). A symlink would not survive the bundling, and a plain copy is what costs the space. Returns the names changed."""
+    bindir = folder / "python" / "bin"
+    if not bindir.is_dir():
+        return []
+    real = bindir / f"python{pt.PYTHON_VERSION.rsplit('.', 1)[0]}"
+    if not real.exists():
+        return []
+    if real.is_symlink():                                  # the real file is a link itself: make the target the real one
+        target = real.resolve()
+        real.unlink()
+        shutil.move(str(target), str(real))
+    changed = []
+    for name in ("python", "python3"):
+        path = bindir / name
+        if not (path.is_symlink() or (path.is_file() and path.stat().st_size == real.stat().st_size)):
+            continue
+        path.unlink()
+        path.write_bytes((LAUNCHER % real.name).encode("utf-8"))
+        path.chmod(0o755)
+        changed.append(name)
+    return changed
+
+
+
+def write_bundle_record(folder: Path, archive: Path) -> dict:
+    manifest_path = archive.with_name(archive.name.rsplit(".", 2 if archive.name.endswith(".tar.gz") else 1)[0] + ".manifest.json")
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8")) if manifest_path.exists() else {}
+    target = manifest.get("target") or pt.host_target()
+    record = {
+        "schema_version": 1, "component": "strata-control",
+        "version": (folder / "VERSION").read_text(encoding="utf-8").strip(),
+        "target": target,
+        "python": {"version": pt.PYTHON_VERSION, "build": pt.PBS_RELEASE, "sha256": pt.PYTHON_PINS[target]["sha256"]},
+        "lock": manifest.get("lock"),
+        "installed": manifest.get("installed"),
+        "archive": {"name": archive.name, "sha256": sha256(archive), "bytes": archive.stat().st_size},
+        "acquires_at_runtime": False,
+        "installer": add_installer(folder),
+    }
+    (folder / "BUNDLE.json").write_text(json.dumps(record, indent=1) + "\n", encoding="utf-8")
+    return record
+
+
+def check(folder: Path) -> int:
+    target = pt.host_target()
+    python = folder / pt.PYTHON_PINS[target]["python"]
+    problems = []
+    for need in (python, folder / "strata.py", folder / "strata_control", folder / "serve" / "server.py", folder / "BUNDLE.json",
+                 folder / "setup.py", folder / "tools" / "strata_mcp.py", folder / "tools" / "iq_pack.py", folder / "data" / "draft_vocab.bin"):
+        if not need.exists():
+            problems.append(f"missing {need}")
+    if problems:
+        print("\n".join(problems), file=sys.stderr)
+        return 1
+    env = {"PYTHONNOUSERSITE": "1", "PYTHONDONTWRITEBYTECODE": "1", "STRATA_NO_ACQUIRE": "1", "SYSTEMROOT": __import__("os").environ.get("SYSTEMROOT", "")}
+    done = subprocess.run([str(python), str(folder / "strata.py"), "--version"], capture_output=True, text=True, env=env,
+                          cwd=str(folder), timeout=60)
+    print(done.stdout.strip() or done.stderr.strip())
+    if done.returncode:
+        return done.returncode
+    # the installer: its catalog, a GPU probe and its imports work on the bundled Python alone (nothing is installed or fetched)
+    probe = ("import sys; sys.path.insert(0, %r); import importlib.util as u; s = u.spec_from_file_location('s', %r); m = u.module_from_spec(s); "
+             "s.loader.exec_module(m); import iq_pack, strata_pack, pack_index, mtp_fetch; "
+             "print('installer ok: %%d models, %%d families' %% (len(m.MODELS), len(m.FAMILIES)))") % (str(folder / "tools"), str(folder / "setup.py"))
+    env["STRATA_CONTROL_INSTALL"] = "1"
+    again = subprocess.run([str(python), "-c", probe], capture_output=True, text=True, env=env, cwd=str(folder), timeout=120)
+    print(again.stdout.strip() or again.stderr.strip()[-600:])
+    return again.returncode
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--archive", type=Path, help="stage this terminal archive instead of building one")
+    ap.add_argument("--wheelhouse", help="build with the wheels in this folder (no network)")
+    ap.add_argument("--out", type=Path, default=OUT)
+    ap.add_argument("--check", action="store_true", help="verify the staged component and exit")
+    a = ap.parse_args()
+    if a.check:
+        return check(a.out)
+    with tempfile.TemporaryDirectory(prefix="strata-stage-control-") as work:
+        archive = a.archive.resolve() if a.archive else build_archive(Path(work), a.wheelhouse)
+        keep = [p for p in a.out.iterdir() if p.name == ".gitignore"] if a.out.exists() else []
+        if a.out.exists():
+            for child in a.out.iterdir():
+                if child.name != ".gitignore":
+                    shutil.rmtree(child, ignore_errors=True) if child.is_dir() else child.unlink()
+        a.out.mkdir(parents=True, exist_ok=True)
+        inner = extract(archive, a.out)
+        record = write_bundle_record(inner, archive)
+        for child in inner.iterdir():
+            shutil.move(str(child), str(a.out / child.name))
+        shutil.rmtree(inner.parent, ignore_errors=True)
+        launched = dedupe_python(a.out)
+        if launched:
+            print(f"python: {', '.join(launched)} are launchers of the one real interpreter")
+        print(f"staged {record['component']} {record['version']} ({record['target']}) into {a.out}")
+    return check(a.out)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+/**
+ * Stage the DeepSeek Harness (pinned, MIT) as the installer's `harness/` folder: a pruned PRODUCTION install, built at
+ * build time, so nothing is fetched or compiled on the person's PC.
+ *
+ *   node apps/desktop/scripts/stage-harness.mjs --src <built Harness checkout> [--out apps/desktop/src-tauri/resources/harness]
+ *
+ * <built Harness checkout> is a clone of the pinned commit after `pnpm install --frozen-lockfile` and `pnpm run build:artifacts`
+ * (see phaseA-tests/notes-split-s4a.md, step 1). The script never touches it: it runs `pnpm deploy --legacy --prod` into
+ * the output folder, removes what a running Harness does not read (sources, tests, maps, docs, other operating systems'
+ * prebuilt binaries, the LibreOffice document converter and the speech engine, which the app does not use), keeps the
+ * MIT licence and third-party notices, writes BUNDLE.json, and finally boots the staged copy once as proof.
+ *
+ * The host finds the result at `<install>/harness` (server/agent/harness-runtime.mjs), or in the component folder.
+ */
+import { spawnSync } from 'node:child_process';
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve, sep } from 'node:path';
+import { createHash } from 'node:crypto';
+import { flattenPnpm } from './flatten-pnpm.mjs';
+import { isOtherOsBinaryFolder, missingHarnessImports } from './harness-prune.mjs';
+import { patchStagedHarnessBudget } from './harness-budget.mjs';
+
+const args = process.argv.slice(2);
+const opt = (name, fallback) => { const i = args.indexOf(`--${name}`); return i >= 0 ? args[i + 1] : fallback; };
+const src = resolve(opt('src', process.env.STRATA_HARNESS_SRC ?? ''));
+const out = resolve(opt('out', join(import.meta.dirname, '..', 'src-tauri', 'resources', 'harness')));
+if (!opt('src', process.env.STRATA_HARNESS_SRC) || !existsSync(join(src, 'apps', 'cli', 'lib', 'bin.js'))) {
+  console.error('Give --src <a built Harness checkout> (apps/cli/lib/bin.js must exist).');
+  process.exit(2);
+}
+const platform = process.platform;
+const run = (cmd, argv, cwd, extra = {}) => {
+  const r = spawnSync(cmd, argv, { cwd, stdio: 'inherit', shell: false, ...extra });
+  if (r.status !== 0) { console.error(`${cmd} ${argv.join(' ')} failed (${r.status ?? r.error})`); process.exit(1); }
+};
+
+// The output folder in the repo carries a .gitignore that keeps the staged files out of git: keep it across the clean-up.
+const keepIgnore = existsSync(join(out, '.gitignore')) ? readFileSync(join(out, '.gitignore')) : null;
+rmSync(out, { recursive: true, force: true });
+mkdirSync(out, { recursive: true });
+const pnpm = platform === 'win32' ? ['corepack.cmd', ['pnpm']] : ['corepack', ['pnpm']];
+run(pnpm[0], [...pnpm[1], 'deploy', '--legacy', '--prod', '--filter', '@deepseek-ai/dsh', out], src, { shell: platform === 'win32' });
+
+// --- peers -------------------------------------------------------------------------------------------------------------
+// `pnpm deploy --prod` leaves out peer dependencies, but the Harness loads some of them by name at run time (for example the
+// plugin-group helper that app-boot imports). Walk the installed packages; every dependency or peer that cannot be
+// resolved from the output is copied from the source checkout's own node_modules, and its own requirements after it.
+function packageJsonsUnder(dir, out2 = []) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isSymbolicLink()) continue;
+    if (e.isDirectory()) packageJsonsUnder(p, out2);
+    else if (e.name === 'package.json' && p.includes(`${sep}node_modules${sep}`)) out2.push(p);
+  }
+  return out2;
+}
+function requirementsOf(file) {
+  try { const j = JSON.parse(readFileSync(file, 'utf8')); return [...Object.keys(j.dependencies ?? {}), ...Object.keys(j.peerDependencies ?? {}), ...Object.keys(j.optionalDependencies ?? {})]; } catch { return []; }
+}
+/** The checkout's own workspace packages (packages/**, vendor/*, apps/*) by name: where a peer that is one of ours comes from. */
+const workspace = new Map();
+function indexWorkspace(dir, depth = 0) {
+  if (depth > 4) return;
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    if (!e.isDirectory() || e.isSymbolicLink() || e.name === 'node_modules' || e.name.startsWith('.')) continue;
+    const p = join(dir, e.name);
+    const manifest = join(p, 'package.json');
+    if (existsSync(manifest)) { try { workspace.set(JSON.parse(readFileSync(manifest, 'utf8')).name, p); } catch { /* not a package */ } }
+    indexWorkspace(p, depth + 1);
+  }
+}
+for (const top of ['packages', 'vendor', 'apps']) if (existsSync(join(src, top))) indexWorkspace(join(src, top));
+const resolvable = name => existsSync(join(out, 'node_modules', ...name.split('/')));
+const queue = [...new Set(packageJsonsUnder(join(out, 'node_modules')).flatMap(requirementsOf))].filter(n => !resolvable(n));
+const added = [];
+while (queue.length) {
+  const name = queue.shift();
+  if (resolvable(name)) continue;
+  const from = workspace.get(name) ?? join(src, 'node_modules', ...name.split('/'));
+  if (!existsSync(from)) continue; // an optional package for another platform, or not installed in the source: nothing to copy
+  const to = join(out, 'node_modules', ...name.split('/'));
+  mkdirSync(join(to, '..'), { recursive: true });
+  const realFrom = realpathSync(from);
+  cpSync(realFrom, to, { recursive: true, dereference: true, filter: f => !relative(realFrom, f).split(sep).includes('node_modules') });
+  added.push(name);
+  queue.push(...requirementsOf(join(to, 'package.json')).filter(n => !resolvable(n)));
+}
+if (added.length) console.log(`peer packages added: ${added.join(', ')}`);
+
+// --- the browser tool server ---------------------------------------------------------------------------------------------
+// Settings -> Tools can switch on a browser the assistant drives (Playwright's MCP server, Apache-2.0) on the person's own Chrome or Edge,
+// so no browser is downloaded. The server and the two Playwright libraries it needs are not part of the Harness's production closure;
+// they are copied from the source checkout's package store (~20 MB) and the host starts it with Node (server/agent/browser-probe.mjs).
+const pnpmStore = join(src, 'node_modules', '.pnpm');
+function storePackage(name, version) {
+  if (!existsSync(pnpmStore)) return null;
+  const prefix = `${name.replace('/', '+')}@`;
+  const hit = readdirSync(pnpmStore).filter(n => n.startsWith(prefix) && (!version || n === `${prefix}${version}` || n.startsWith(`${prefix}${version}_`))).sort().at(-1);
+  const dir = hit ? join(pnpmStore, hit, 'node_modules', ...name.split('/')) : null;
+  return dir && existsSync(dir) ? dir : null;
+}
+const browserDir = storePackage('@playwright/mcp');
+if (browserDir) {
+  const wanted = JSON.parse(readFileSync(join(browserDir, 'package.json'), 'utf8')).dependencies ?? {};
+  const parts = [['@playwright/mcp', browserDir], ...['playwright', 'playwright-core'].map(n => [n, storePackage(n, wanted[n])])];
+  if (parts.every(([, dir]) => dir)) {
+    for (const [name, dir] of parts) {
+      const to = join(out, 'node_modules', ...name.split('/'));
+      mkdirSync(join(to, '..'), { recursive: true });
+      cpSync(realpathSync(dir), to, { recursive: true, dereference: true, filter: f => !relative(dir, f).split(sep).includes('node_modules') });
+    }
+    console.log(`browser tool server added: ${parts.map(([n]) => n).join(', ')}`);
+  } else console.log('browser tool server NOT added: Playwright libraries missing from the package store');
+} else console.log('browser tool server NOT added: @playwright/mcp is not in the source checkout');
+
+// --- one real folder per package, no links -------------------------------------------------------------------------------
+// The installer copies files; pnpm's layout is links. See flatten-pnpm.mjs. The two packages the app does not use are never copied.
+const flat = flattenPnpm(out, { skip: /libreoffice-kit|sherpa-onnx/i });
+console.log(`flattened: ${flat.packages} placed (${flat.nested} nested for a second version)`);
+
+// --- prune ------------------------------------------------------------------------------------------------------------
+/** Whole packages the app never loads: office-document conversion (hundreds of MB) and speech input. */
+const DROP_PACKAGES = [/libreoffice-kit/i, /sherpa-onnx/i];
+/** Only when sitting directly in a package's root (a library may have a runtime folder called `doc`, e.g. yaml/dist/doc). */
+const DROP_DIRS = new Set(['test', 'tests', '__tests__', 'docs', 'website', 'benchmarks', 'examples', '.github']);
+const DROP_FILES = /\.(map|md|markdown|pdb|tsbuildinfo)$/i;
+/** Licences and notices travel with the files they cover. */
+const KEEP_FILES = /^(LICENSE|LICENCE|NOTICE|THIRD_PARTY)/i;
+let removed = 0;
+function prune(dir) {
+  for (const e of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, e.name);
+    if (e.isSymbolicLink()) continue;
+    if (e.isDirectory()) {
+      const inLib = p.split(sep).includes('lib');
+      if ((DROP_DIRS.has(e.name) && !inLib && existsSync(join(dir, 'package.json'))) || DROP_PACKAGES.some(r => r.test(e.name)) || isOtherOsBinaryFolder(platform, e.name, p)) {
+        rmSync(p, { recursive: true, force: true }); removed++; continue;
+      }
+      prune(p);
+    } else if (DROP_FILES.test(e.name) && !KEEP_FILES.test(e.name)) {
+      rmSync(p, { force: true }); removed++;
+    }
+  }
+}
+prune(out);
+
+// Strata's provenance-recorded output-budget correction applies only to this copy.
+const patches = [patchStagedHarnessBudget(out)];
+
+// --- licence: the MIT text and the third-party notices travel with the files ---------------------------------------------
+for (const name of ['LICENSE', 'THIRD_PARTY_NOTICES.md']) {
+  if (existsSync(join(src, name))) cpSync(join(src, name), join(out, name));
+}
+const cli = JSON.parse(readFileSync(join(out, 'package.json'), 'utf8'));
+let commit = process.env.STRATA_HARNESS_COMMIT ?? null;
+if (!commit) { const r = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: src, encoding: 'utf8' }); if (r.status === 0) commit = r.stdout.trim(); }
+function size(dir) { let t = 0, n = 0; for (const e of readdirSync(dir, { withFileTypes: true })) { const p = join(dir, e.name); if (e.isDirectory()) { const s = size(p); t += s.bytes; n += s.files; } else if (e.isFile()) { t += statSync(p).size; n++; } } return { bytes: t, files: n }; }
+const total = size(out);
+writeFileSync(join(out, 'BUNDLE.json'), JSON.stringify({
+  component: 'deepseek-harness', version: cli.version, commit, license: 'MIT', platform, node: process.version,
+  bytes: total.bytes, files: total.files, entry: 'apps/cli/lib/bin.js', builtAt: new Date().toISOString(),
+  patches,
+  note: 'Pruned production install (pnpm deploy --prod). No package manager runs on the user\'s PC.',
+}, null, 2));
+
+if (keepIgnore) writeFileSync(join(out, '.gitignore'), keepIgnore);
+
+// --- proof 1: nothing the Harness imports by name was pruned ------------------------------------------------------------
+// (2026-10-17: the other-OS rule once removed @deepseek-ai/dsh-win32-process, which every platform imports; Linux/Mac agent chats died.)
+const lost = missingHarnessImports(out);
+if (lost.length) { console.error(['staged Harness is missing imported packages:', ...lost.map(l => `  ${l.from} -> ${l.missing}`)].join(String.fromCharCode(10))); process.exit(1); }
+console.log('import check: every @deepseek-ai package the Harness imports is staged');
+
+// --- proof 2: the staged copy answers --version and boots the web profile once ----------------------------------------
+const bin = join(out, 'apps', 'cli', 'lib', 'bin.js');
+const entry = existsSync(bin) ? bin : join(out, 'lib', 'bin.js');
+const v = spawnSync(process.execPath, [entry, '--version'], { encoding: 'utf8' });
+if (v.status !== 0) { console.error('staged Harness does not start:', v.stderr); process.exit(1); }
+console.log(`staged ${cli.version} (${commit?.slice(0, 8) ?? 'no commit'}) in ${out}: ${(total.bytes / 1048576).toFixed(0)} MiB, ${total.files} files, ${removed} pruned items; --version -> ${v.stdout.trim()}`);
+console.log(`sha256(BUNDLE.json)=${createHash('sha256').update(readFileSync(join(out, 'BUNDLE.json'))).digest('hex')}`);
@@ -0,0 +1,721 @@
+#!/usr/bin/env node
+/**
+ * Headless UI flows of the installed app against a packaged host with a FAKE installer and a FAKE engine (nothing is
+ * downloaded, no real engine runs; the real Control starts the fake engine through the owner runtime):
+ *
+ *   node apps/desktop/scripts/ui-flows.mjs [--control <staged control>] [--node <node.exe>] [--shots <dir>] [--only download,models,tune,fail,theme]
+ *
+ *   download  the onboarding download: ONE combined bar over both files, an ETA in minutes left of Stop, Finish later closes the
+ *             pop-up with the download still running, the Models screen shows the same progress, Stop stops it
+ *   models    an installed model is the one Models selects and loads, without a download pop-up
+ *   tune      the tuning step offers no picture reading, tunes, writes a RAM budget for "leave 20%", opens chat; reading size
+ *   fail      an engine that stops while loading: the error is in words and the pop-up does not scroll
+ *   theme     the app follows the system light/dark setting
+ * Per-user folders are all under a scratch folder. Exit 1 if a check fails.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, rmdirSync, symlinkSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') ? true : all[i + 1]]] : acc), []));
+const here = dirname(fileURLToPath(import.meta.url));
+const repoHost = resolve(here, '../../host');
+const staged = resolve(here, '../src-tauri/resources');
+const stagedControl = resolve(args.control ?? join(staged, 'control'));
+const nodeExe = resolve(args.node ?? join(staged, 'node', process.platform === 'win32' ? 'node.exe' : 'node'));
+const work = mkdtempSync(join(tmpdir(), 'strata-ui-flows-'));
+const shots = resolve(args.shots ?? join(work, 'shots'));
+mkdirSync(shots, { recursive: true });
+const only = new Set(String(args.only ?? 'download,models,profile,ui2,ui2d,tune,fail,delete,theme,restart,perf,polish,stop,latest').split(','));
+const isWin = process.platform === 'win32';
+const { chromium } = await import(pathToFileURL(join(repoHost, 'node_modules/playwright-core/index.mjs')).href).catch(() => import('playwright-core'));
+const CHROME = process.env.CHROME ?? ['C:/Program Files/Google/Chrome/Application/chrome.exe', '/usr/bin/google-chrome'].find(existsSync);
+const delay = ms => new Promise(r => setTimeout(r, ms));
+const sha = buf => createHash('sha256').update(buf).digest('hex');
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+let failed = false;
+const check = (ok, label, detail = '') => { console.log(`${ok ? 'ok  ' : 'FAIL'} ${label}${detail ? '  ' + detail : ''}`); if (!ok) failed = true; };
+
+// ------------------------------------------------------------------ the app folder: the real Control with a fake installer
+const control = join(work, 'control');
+mkdirSync(control, { recursive: true });
+for (const name of ['python', 'strata_control', 'strata_cli', 'serve']) symlinkSync(join(stagedControl, name), join(control, name), 'junction');
+for (const name of ['strata.py', 'VERSION', 'BUNDLE.json', 'requirements.txt']) copyFileSync(join(stagedControl, name), join(control, name));
+cpSync(join(stagedControl, 'tools'), join(control, 'tools'), { recursive: true });
+const python = isWin ? join(control, 'python', 'python.exe') : join(control, 'python', 'bin', 'python3');
+
+const FAKE_INSTALLER = String.raw`
+import json, os, sys, time
+from pathlib import Path
+ROOT = Path(sys.argv[sys.argv.index('--root') + 1]) if '--root' in sys.argv else Path('.')
+STATE = Path(os.environ['FAKE_STATE']); STATE.mkdir(parents=True, exist_ok=True)
+RATE = float(os.environ.get('FAKE_RATE_GB_S', '0.5'))
+def size(model, gb, ram, mid):
+    return {'model': model, 'about': model, 'download_gb': gb, 'ram_needed_gb': ram, 'experts_gb': ram - 8, 'on_this_pc': 'fits', 'installed': False, 'images': True, 'experimental': False, 'id': mid}
+CATALOG = {'summary': 'fake', 'families': [{'family': 'qwen', 'title': 'Qwen3.8-Flash-Next', 'about': 'x', 'experimental': False, 'images': True, 'sizes': [
+    size('Q2_0', 66.4, 48, 'q2_0'), size('IQ3_XXS', 75.8, 60, 'iq3_xxs'), size('IQ3_S', 83.6, 62, 'iq3_s')]}],
+    'contexts': [8192, 32768, 65536], 'recommendation': {'family': 'qwen', 'model': 'IQ3_XXS', 'title': 'Qwen3.8-Flash-Next IQ3_XXS', 'context': 32768}, 'context_note': ''}
+HARDWARE = {'ram_gb': 63.1, 'cpu': {'name': 'cpu', 'cores': 12}, 'gpus': [{'index': 0, 'name': 'NVIDIA GeForce RTX 5070', 'vram_gb': 11.9, 'usable': True}]}
+TOTAL = 83.6
+def job():
+    f = STATE / 'job.json'
+    if not f.exists(): return None
+    j = json.loads(f.read_text())
+    if j.get('cancelled'):
+        return {'running': False, 'exit_code': 1, 'error': 'stopped', 'result': 'failed'}
+    done = min(TOTAL, RATE * (time.time() - j['start']))
+    return {'running': True, 'step': '5/7: downloading Qwen3.8-Flash-Next IQ3_S', 'model': 'IQ3_S',
+            'download': {'file': 'model files', 'done_gb': round(done, 3), 'total_gb': TOTAL, 'remaining_gb': round(TOTAL - done, 3), 'percent': int(100 * done / TOTAL)}}
+def call(name, a):
+    if name == 'strata_models': return CATALOG
+    if name == 'strata_remove':
+        cfg = ROOT / ('strata-%s.json' % a['model'])
+        if a.get('confirm') and cfg.exists(): cfg.unlink()
+        return {'summary': 'Deleted', 'plan': {'gb': 83.6}, 'failed': []}
+    if name == 'strata_status': return {'summary': 'fake', 'installed': {'models': [{'model': 'iq3_s', 'disk_gb': 83.6, 'disk_bytes': 83600000000}]}, 'hardware': HARDWARE, 'recommendation': CATALOG['recommendation'], 'install': job(), 'running': []}
+    if name == 'strata_install':
+        if a.get('cancel'):
+            f = STATE / 'job.json'
+            if f.exists(): j = json.loads(f.read_text()); j['cancelled'] = True; f.write_text(json.dumps(j))
+            return {'summary': 'stopped', 'install': job()}
+        if a.get('confirm'):
+            (STATE / 'job.json').write_text(json.dumps({'start': time.time()}))
+            return {'summary': 'started', 'plan': {'download_gb': TOTAL}, 'install': job()}
+        if not a: return {'summary': 'progress', 'install': job()}
+        return {'summary': 'Plan', 'plan': {'title': 'Qwen3.8-Flash-Next IQ3_S', 'download_gb': TOTAL, 'disk_short': None}}
+    raise Exception('unknown tool ' + name)
+for line in sys.stdin:
+    line = line.strip()
+    if not line: continue
+    m = json.loads(line)
+    if 'id' not in m: continue
+    method = m.get('method')
+    if method == 'initialize': res = {'protocolVersion': '2024-11-05'}
+    elif method == 'tools/list': res = {'tools': [{'name': n} for n in ('strata_models', 'strata_status', 'strata_install', 'strata_remove')]}
+    else:
+        p = m['params']
+        res = {'structuredContent': call(p['name'], p.get('arguments') or {})}
+    sys.stdout.write(json.dumps({'jsonrpc': '2.0', 'id': m['id'], 'result': res}) + '\n'); sys.stdout.flush()
+`;
+writeFileSync(join(control, 'tools', 'strata_mcp.py'), FAKE_INSTALLER);
+
+const FAKE_ENGINE = `import os, sys, json, time
+from pathlib import Path
+if os.environ.get('FAKE_ENGINE_FAIL'):
+    print('memory guard: 5.1 GiB of RAM free is under the 6 GiB limit (limit 63.1 GiB)', flush=True)
+    sys.exit(3)
+ctx = '4096'
+if '--max-context' in sys.argv: ctx = sys.argv[sys.argv.index('--max-context') + 1]
+print('READY %s stop' % ctx, flush=True)
+for line in sys.stdin:
+    if line.strip() == 'QUIT': break
+    if line.startswith(('GEN ', 'BGEN ')):
+        slot = int(line.split()[1]) if line.startswith('BGEN ') else None
+        t0 = time.time(); n = 0
+        for ch in os.environ.get('FAKE_REPLY', 'a'):
+            print('T %d' % ord(ch), flush=True); n += 1
+            if os.environ.get('FAKE_TOKEN_DELAY'): time.sleep(float(os.environ['FAKE_TOKEN_DELAY']))
+        print('DONE %d 12 300.0 %.1f length 0 0 0' % (n, max(1.0, (time.time() - t0) * 1000)), flush=True)
+        if slot is not None: print(f'BADM {slot} 0', flush=True)
+`;
+
+// one scenario = one fresh host with its own per-user folders
+async function scenario(name, { installed = false, env = {} } = {}, body) {
+  if (!only.has(name)) return;
+  console.log(`--- ${name}`);
+  const dir = join(work, name);
+  const dirs = { home: join(dir, 'home'), appdata: join(dir, 'appdata'), local: join(dir, 'local'), components: join(dir, 'local', 'Strata', 'components'), install: join(dir, 'local', 'Strata', 'install'), state: join(dir, 'fake-state'), profiles: join(dir, 'profiles'), runtime: join(dir, 'runtime') };
+  for (const d of [dirs.home, dirs.appdata, dirs.local, dirs.components, dirs.install, dirs.state, join(dir, 'models')]) mkdirSync(d, { recursive: true });
+  const baseEnv = { ...process.env, STRATA_COMPONENTS_DIR: dirs.components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime, STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(dir, 'models'), APPDATA: dirs.appdata, LOCALAPPDATA: dirs.local, USERPROFILE: dirs.home, XDG_CONFIG_HOME: join(dir, 'xdg'), XDG_DATA_HOME: join(dir, 'xdgdata'), PYTHONDONTWRITEBYTECODE: '1', STRATA_ENGINE_BACKEND: 'cuda', FAKE_STATE: dirs.state, ...env };
+  delete baseEnv.STRATA_API_KEY; delete baseEnv.STRATA_INSTALL_DIR;
+  if (installed) {
+    const platform = isWin ? 'windows-x86_64' : 'linux-x86_64';
+    const folder = join(dirs.components, 'engine', `0.1.45-${platform}-cuda`);
+    mkdirSync(folder, { recursive: true });
+    writeFileSync(join(folder, 'engine_main.py'), FAKE_ENGINE);
+    const entry = isWin ? 'engine.cmd' : 'engine';
+    writeFileSync(join(folder, entry), isWin ? `@echo off\r\n"${python}" "%~dp0engine_main.py" %*\r\n` : `#!/bin/sh\nexec "${python}" "$(dirname "$0")/engine_main.py" "$@"\n`);
+    const files = [entry, 'engine_main.py'].map(p => { const b = readFileSync(join(folder, p)); return { path: p, sha256: sha(b), bytes: b.length }; });
+    writeFileSync(join(folder, 'engine-component.json'), JSON.stringify({ schema_version: 1, id: 'strata-engine', version: '0.1.45', platform, backend: 'cuda', entrypoint: entry, files }));
+    const tok = join(dirs.install, 'tokenizer');
+    mkdirSync(tok, { recursive: true });
+    const script = `import json, sys\nfrom tools.strata_tokenizer import BYTE_TO_UNICODE\ntok = sys.argv[1]\ntokens = [BYTE_TO_UNICODE[i] for i in range(256)] + ['ab', '<|im_start|>', '<|im_end|>', '<|endoftext|>']\njson.dump({t: i for i, t in enumerate(tokens)}, open(tok + '/vocab.json', 'w'))\nopen(tok + '/merges.txt', 'w').write('a b')\njson.dump([0] * 257 + [3, 3, 3], open(tok + '/token_type.json', 'w'))\n`;
+    const made = spawnSync(python, ['-c', script, tok], { cwd: control, env: { ...baseEnv, PYTHONNOUSERSITE: '1' }, encoding: 'utf8' });
+    if (made.status !== 0) throw new Error('tokenizer fixture: ' + made.stderr);
+    writeFileSync(join(dirs.install, 'strata-iq3_s.json'), JSON.stringify({ exe: 'component:strata-engine', backend: 'cuda', tokenizer: tok, args: ['--max-context', '32768', '--pool-workers', '12'], cwd: dir, model_name: 'stub', host: '127.0.0.1', port: 0, kv: 'int8' }));
+  }
+  const port = env.FIXED_PORT ? Number(env.FIXED_PORT) : await freePort(), base = `http://127.0.0.1:${port}`;
+  const host = spawn(nodeExe, [join(repoHost, 'server', 'index.mjs')], { cwd: repoHost, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true,
+    env: { ...baseEnv, STRATA_PORT: String(port), STRATA_DIST: join(repoHost, 'dist'), STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1', STRATA_CONTROL_DIR: control, STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()) } });
+  let log = ''; host.stdout.on('data', c => { log += c; }); host.stderr.on('data', c => { log += c; });
+  const api = async (path, init) => { const r = await fetch(base + path, init); return { status: r.status, body: await r.json().catch(() => null) }; };
+  const browser = await chromium.launch({ executablePath: CHROME, headless: true });
+  try {
+    let up = false;
+    for (let i = 0; i < 200 && !up; i++) { try { up = (await api('/api/health')).status === 200; } catch { await delay(150); } }
+    check(up, `${name}: the packaged host starts`);
+    await api('/api/native?refresh=1');
+    await body({ base, api, browser, dirs, shot: (page, n) => page.screenshot({ path: join(shots, `${name}-${n}.png`) }), log: () => log });
+  } catch (error) {
+    check(false, `${name}: the flow`, String(error?.stack ?? error).slice(0, 700) + '\n' + log.slice(-600));
+  } finally {
+    await browser.close().catch(() => {});
+    host.kill(); await new Promise(r => host.once('exit', r));
+  }
+}
+const newPage = async (browser, base, options = {}) => {
+  const context = await browser.newContext({ viewport: { width: 1400, height: 950 }, ...(process.env.SCHEME ? { colorScheme: process.env.SCHEME } : {}), ...options });
+  const page = await context.newPage();
+  const problems = [];
+  page.on('pageerror', e => problems.push(e.message));
+  page.problems = problems;
+  await page.goto(base, { waitUntil: 'domcontentloaded' });
+  return page;
+};
+const clickText = async (page, re, timeout = 30000) => { const b = page.getByRole('button', { name: re }).first(); await b.waitFor({ timeout }); await b.click(); };
+const noScroll = async page => page.evaluate(() => {
+  const root = document.querySelector('.guided-onboarding');
+  const bad = [];
+  for (let el = document.querySelector('.onboard-tune-stage, .onboard-prepare-stage, .onboard-model-stage') ?? root; el && el !== document.body; el = el.parentElement) {
+    const style = getComputedStyle(el);
+    if (/(auto|scroll)/.test(style.overflowY) && el.scrollHeight > el.clientHeight + 1) bad.push(`${el.className || el.tagName}: ${el.scrollHeight} > ${el.clientHeight}`);
+  }
+  return bad;
+});
+
+// ------------------------------------------------------------------------------------------------ download
+await scenario('download', {}, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /get started/i);
+  await page.getByText(/Choose a version/i).waitFor({ timeout: 30000 });
+  await page.locator('[role=radio]').filter({ hasText: 'IQ3_S' }).first().click();
+  await clickText(page, /^Continue/);
+  await clickText(page, /Download model/i, 60000);
+  await page.locator('.onboard-progress progress').waitFor({ timeout: 30000 });
+  // ONE bar: sample the percent while it runs, it only goes up
+  const samples = [];
+  let eta = '';
+  for (let i = 0; i < 40 && !eta; i++) {
+    const state = (await api('/api/native')).body;
+    const d = state.jobs.at(-1)?.result?.install?.download;
+    if (d) samples.push(d.done_gb);
+    eta = (await page.locator('.onboard-progress-actions span').first().textContent({ timeout: 1000 }).catch(() => '')) ?? '';
+    await delay(1000);
+  }
+  await shot(page, '1-wizard-progress');
+  check(/About \d+ (min left|h)/.test(eta), 'the wizard shows about how many minutes are left', eta.trim());
+  const order = await page.evaluate(() => { const a = document.querySelector('.onboard-progress-actions'); const kids = a ? [...a.children].map(k => k.tagName + ':' + Math.round(k.getBoundingClientRect().left)) : []; return kids; });
+  check(order.length === 2 && order[0].startsWith('SPAN') && order[1].startsWith('BUTTON') && Number(order[0].split(':')[1]) < Number(order[1].split(':')[1]), 'the time left sits left of Stop', order.join(' '));
+  check(samples.length >= 3 && samples.every((v, i) => i === 0 || v >= samples[i - 1]), 'one combined count that only goes up', samples.map(v => v.toFixed(1)).join(', '));
+  const meta = await page.locator('.onboard-progress-meta span').first().textContent();
+  check(/GB/.test(meta ?? '') && /83\.6/.test(meta ?? ''), 'the bar says done / total over the whole model', meta);
+  // close the pop-up while it downloads
+  await clickText(page, /Finish later/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByText(/Preparing your model/i).waitFor({ timeout: 15000 }).catch(() => {});
+  await delay(1500);
+  await shot(page, '2-models-progress');
+  await page.locator('.native-progress').first().screenshot({ path: join(shots, 'download-3-models-progress-card.png') }).catch(() => {});
+  check(await page.locator('.guided-onboarding').count() === 0, 'the setup pop-up closed');
+  check(await page.getByText(/Preparing your model/i).count() > 0, 'the Models screen shows the running download');
+  const still = (await api('/api/native')).body.jobs.at(-1);
+  check(still?.state === 'running', 'the download keeps running in the background', still?.state);
+  const modelsEta = await page.locator('.native-progress .onboard-progress-actions span').first().textContent({ timeout: 15000 }).catch(() => '');
+  check(/About \d+ (min left|h)/.test(modelsEta ?? ''), 'the Models screen shows the time left too', (modelsEta ?? '').trim());
+  await clickText(page, /^Stop$/);
+  await delay(2500);
+  check((await api('/api/native')).body.jobs.at(-1)?.state !== 'running', 'Stop stops it');
+  check(page.problems.length === 0, 'no page error', page.problems.join('; '));
+});
+
+// ------------------------------------------------------------------------------------------------ models
+await scenario('models', { installed: true }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByText(/Conversation context/i).first().waitFor({ timeout: 30000 });
+  await delay(1500);
+  await shot(page, '1-models');
+  await page.locator('.version-trigger').first().waitFor({ timeout: 20000 }).catch(async () => { await shot(page, '0-models-missing-summary'); console.log('info  page text:', JSON.stringify((await page.locator('body').innerText()).slice(0, 500))); });
+  const summary = await page.locator('.version-trigger').first().textContent({ timeout: 5000 }).catch(() => '');
+  // the Models tab fits the first view: nothing to scroll while no list is open and Expert mode is closed
+  if (await page.getByRole('button', { name: /^Close expert mode$/ }).count()) { await page.getByRole('button', { name: /^Close expert mode$/ }).click(); await delay(500); }
+  await shot(page, '1b-models-one-view');
+  const overflow = await page.evaluate(() => { const el = document.querySelector('.main__body'); return el ? el.scrollHeight - el.clientHeight : 0; });
+  check(overflow <= 2, 'the Models tab fits the first view without scrolling', String(overflow) + ' px over');
+  check(await page.locator('.family-switch').count() === 1, 'the model family switch is in the navbar');
+  check(await page.locator('h1').filter({ hasText: /^Model$/ }).count() === 0, 'and the navbar does not say "Model"');
+  check(/IQ3_S|High quality/.test(summary ?? ''), 'Models selects the model that is on this PC, not the recommendation', (summary ?? '').replace(/\s+/g, ' ').trim());
+  check(!/IQ3_XXS|Balanced/.test(summary ?? ''), 'the recommendation (IQ3_XXS) is not what is selected');
+  const load = page.getByRole('button', { name: /^Load model$/ }).first();
+  await load.click();
+  await delay(1200);
+  check(await page.getByRole('dialog').filter({ hasText: /Download and prepare/i }).count() === 0, 'loading an installed model opens no download pop-up');
+  let ready = false;
+  for (let i = 0; i < 90 && !ready; i++) { const s = (await api('/api/native')).body; ready = s.instances.some(x => x.status === 'ready'); const err = s.instances.find(x => x.status === 'error'); if (err) throw new Error('load failed: ' + err.error); await delay(1000); }
+  if (!ready) { const st = (await api('/api/native')).body; console.log('info  jobs', JSON.stringify(st.jobs.map(j => [j.kind, j.state, j.error ?? j.summary])), 'instances', JSON.stringify(st.instances.map(i => [i.status, i.error]))); await shot(page, '2-models-after-click'); }
+  check(ready, 'the model loads (a fake engine under the real Control)');
+  await page.reload({ waitUntil: 'domcontentloaded' });
+  await page.getByRole('button', { name: /^Unload$/ }).first().waitFor({ timeout: 30000 }).catch(() => {});
+  await shot(page, '3-models-loaded');
+  check(await page.getByRole('button', { name: /^Unload$/ }).count() > 0, 'after a reload the Models screen shows the model as loaded, with Unload');
+  check(await page.getByRole('button', { name: /^Load model$/ }).count() === 0, 'and no longer offers Load model');
+  await page.getByRole('button', { name: /^Unload$/ }).first().click();
+  let gone = false;
+  for (let i = 0; i < 40 && !gone; i++) { gone = (await api('/api/native')).body.instances.length === 0; await delay(500); }
+  check(gone, 'Unload stops the engine');
+  await page.getByRole('button', { name: /^Load model$/ }).first().waitFor({ timeout: 15000 }).catch(() => {});
+  check(await page.getByRole('button', { name: /^Load model$/ }).count() > 0, 'and Load model is back');
+  check(page.problems.length === 0, 'no page error', page.problems.join('; '));
+});
+
+// ------------------------------------------------------------------------------------------------ the profile used, the popover, the pop-up
+await scenario('profile', { installed: true }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.getByText(/Conversation context/i).first().waitFor({ timeout: 30000 });
+  await delay(1500);
+  const work = () => page.getByRole('button', { name: /Leave 20% for my work/ }).first();
+  const full = () => page.getByRole('button', { name: /Full performance/ }).first();
+  await work().click();
+  check(await work().getAttribute('aria-pressed') === 'true', 'Leave 20% is chosen before loading');
+  await page.getByRole('button', { name: /^Load model$/ }).first().click();
+  let ready = false;
+  for (let i = 0; i < 90 && !ready; i++) { const s = (await api('/api/native')).body; ready = s.instances.some(x => x.status === 'ready'); await delay(500); }
+  check(ready, 'the model loads');
+  const inst = (await api('/api/native')).body.instances.find(x => x.status === 'ready');
+  check(inst?.resourceProfile === 'work', 'the running model reports the profile it was started with', String(inst?.resourceProfile));
+  await delay(1500);
+  check(await work().getAttribute('aria-pressed') === 'true' && await full().getAttribute('aria-pressed') === 'false', 'after the load the page still shows Leave 20%, not Full performance');
+  await page.reload({ waitUntil: 'domcontentloaded' });
+  await page.getByRole('button', { name: /^Unload$/ }).first().waitFor({ timeout: 30000 });
+  await delay(1000);
+  check(await work().getAttribute('aria-pressed') === 'true', 'and after a reload it is still the profile in use');
+  await shot(page, '1-profile-used');
+  // the reasoning popover names the loaded model
+  await page.evaluate(() => { location.hash = '#/chat'; });
+  const effort = page.getByRole('button', { name: /^Reasoning effort/ }).first();
+  await effort.waitFor({ timeout: 30000 });
+  await effort.click();
+  const header = await page.locator('.reasoning-menu-model strong').first().textContent({ timeout: 10000 });
+  check(header && !/No model loaded/i.test(header), 'the Reasoning popover names the loaded model, not "No model loaded"', String(header));
+  await shot(page, '2-reasoning-popover');
+  await page.keyboard.press('Escape');
+  // an installed model asked for with other settings: the pop-up never speaks of downloading
+  await page.evaluate(() => { location.hash = '#/models'; });
+  await page.getByRole('button', { name: /^Unload$/ }).first().waitFor({ timeout: 30000 });
+  await page.getByRole('button', { name: /^Unload$/ }).first().click();
+  await page.getByRole('button', { name: /^Load model$/ }).first().waitFor({ timeout: 30000 });
+  await page.getByRole('combobox', { name: 'Conversation context' }).first().click();
+  const options = page.getByRole('option');
+  const pick = (await options.allTextContents()).findIndex(t => /^8K$/.test(t.trim()));
+  if (pick >= 0) await options.nth(pick).click();
+  await page.getByRole('button', { name: /^Load model$|^Checking/ }).first().click();
+  const dialog = page.getByRole('dialog').first();
+  await dialog.waitFor({ timeout: 15000 }).catch(() => {});
+  const text = (await dialog.textContent().catch(() => '')) ?? '';
+  await shot(page, '3-apply-dialog');
+  if (text) {
+    check(!/Download and prepare|Download . load|approximately|[0-9] GB/i.test(text), 'for a downloaded model the pop-up has no download wording or size', text.replace(/\s+/g, ' ').slice(0, 600));
+    check(/Apply/.test(text), 'it says what happens: apply settings and load');
+  } else console.log('info  the settings were the saved ones, so loading needed no pop-up at all');
+  check(page.problems.length === 0, 'no page error', page.problems.join('; '));
+});
+
+// ------------------------------------------------------------------------------------------------ version list, This computer, Tune, a task
+for (const scheme of ['light', 'dark']) await scenario(scheme === 'light' ? 'ui2' : 'ui2d', { installed: true, env: { FAKE_TOKEN_DELAY: '0.02', FAKE_REPLY: 'I am thinking about it. </think> ' + 'Here is the answer, word by word. '.repeat(12), STRATA_TUNE_NO_QUIET_CHECK: '1' } }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base, { colorScheme: scheme });
+  await clickText(page, /Go straight to the app/i);
+  await page.getByText(/Conversation context/i).first().waitFor({ timeout: 30000 });
+  await delay(1500);
+  // the version list: Recommended (the fixed four), then folded groups, one line per model
+  console.log('info  triggers', await page.locator('.version-trigger').count(), await page.getByRole('button', { name: 'Model version' }).count());
+  await page.locator('.version-trigger').first().click();
+  await delay(300);
+  console.log('info  expanded after click', await page.locator('.version-trigger').first().getAttribute('aria-expanded'));
+  await delay(800); await shot(page, `0-after-click-${scheme}`);
+  console.log('info  menu', await page.evaluate(() => { const m = document.querySelector('.version-menu'); const t = document.querySelector('.version-trigger'); return JSON.stringify({ menu: m ? m.getBoundingClientRect() : null, parent: m ? [m.parentElement.className, getComputedStyle(m.parentElement).display, getComputedStyle(m.parentElement).visibility, m.parentElement.style.cssText.slice(0, 120)] : null, expanded: t?.getAttribute('aria-expanded'), roles: [...document.querySelectorAll('[role=menu]')].length }); }));
+  await page.locator('.version-menu').waitFor({ timeout: 10000 });
+  const heads = await page.locator('.version-head span:first-child, .version-group__head').allTextContents();
+  const names = await page.locator('.version-menu > .version-row .version-row__name strong').allTextContents();
+  console.log('info  version list', JSON.stringify(heads.map(t => t.replace(/\s+/g, ' ').trim())), JSON.stringify(names));
+  check(heads[0]?.trim() === 'Recommended', `${scheme}: the list starts with Recommended`);
+  check(names.length >= 1 && names.length <= 4, `${scheme}: Recommended shows only the picks this catalog has (at most the fixed four)`, names.join(' | '));
+  check(heads.some(t => /Swift models|GSQ-RCO models|Gyro models|NVFP4 models|Unsloth models/.test(t)), `${scheme}: the other models are in folded groups`);
+  check(heads.at(-1)?.includes('Use your own GGUF'), `${scheme}: the last row is Use your own GGUF`);
+  const tall = await page.locator('.version-row').evaluateAll(els => els.filter(e => e.getBoundingClientRect().height > 44).length);
+  check(tall === 0, `${scheme}: every model is one line`, String(tall));
+  await shot(page, `1-versions-${scheme}`);
+  await page.keyboard.press('Escape');
+  // This computer
+  const pc = page.locator('.pc-card');
+  await pc.waitFor({ timeout: 10000 });
+  const pcText = ((await pc.textContent()) ?? '').replace(/\s+/g, ' ');
+  check(/This computer/.test(pcText) && /(Fits fully in memory|read from the SSD)/.test(pcText), `${scheme}: This computer says in one line whether it fits`, pcText.slice(0, 200));
+  check(await pc.locator('.pc-meter').count() >= 1, `${scheme}: it shows the memory bars`);
+  check(await pc.locator('.chip, .st-pill, [class*="badge"]').count() === 0, `${scheme}: no chips or badges in it`);
+  await shot(page, `2-computer-${scheme}`);
+  // Tune: five steps, a live speed, a result card
+  await page.getByRole('button', { name: /^Tune model$/ }).first().click({ timeout: 10000 });
+  await delay(1500); await shot(page, `2b-tune-dialog-${scheme}`);
+  // The fake engine has no other setting worth trying, so its tune passes through "trying" too fast to be seen. The page is shown the progress a
+  // real tune reports (Control's status file: stage, speeds) for the running view; the start, the result and every other call are real.
+  let fakePhase = 'run';
+  await page.route('**/api/native*', async route => {
+    const response = await route.fetch(); let json = null;
+    try { json = await response.json(); } catch { return route.fulfill({ response }); }
+    for (const job of json?.jobs ?? []) if (job.kind === 'autotune' && fakePhase === 'done') { job.state = 'done'; job.progress = null; job.result = { outcome: 'improved', gain_pct: 18, base: { decode_tok_s: 41.2 }, chosen: { decode_tok_s: 48.6 }, preset: { id: 'fast', name: 'Fast · 64K' }, answers: { class: 'exact', fields: [] } }; } else if (job.kind === 'autotune' && job.state === 'running') job.progress = { stage: 'rounds', text: null, minutesLeft: 9, runsDone: 3, runsPlanned: 6, elapsedS: 300, step: 'Trying: more experts kept in memory (round 1 of 2)', speeds: [{ label: 'base', tok_s: 41.2 }, { label: 'Fewer helper threads', tok_s: 40.1 }, { label: 'More experts kept in memory', tok_s: 46.8 }] };
+    return route.fulfill({ response, json });
+  });
+  await page.getByRole('button', { name: /Start tuning|Tune again/ }).first().click({ timeout: 15000 });
+  await page.locator('.tune-step').first().waitFor({ timeout: 60000 });
+  check(await page.locator('.tune-step').count() === 5, `${scheme}: the tuner shows its five steps`);
+  let sawRun = false, sawSpeed = false;
+  for (let i = 0; i < 400; i++) {
+    const done = await page.locator('.tune-result, .tune-progress').count();
+    if (i % 4 === 0) { const jobs = (await api('/api/native')).body?.jobs ?? []; const j = jobs.find(x => x.kind === 'autotune'); if (j) console.log('info  tune job', j.state, JSON.stringify(j.progress ?? null).slice(0, 300)); }
+    if (await page.locator('.tune-step[data-s=run]').count()) sawRun = true;
+    const big = await page.locator('.tune-live__big').first().textContent().catch(() => '');
+    if (/[0-9]/.test(big ?? '')) sawSpeed = true;
+    if (sawRun && sawSpeed) { await delay(700); await shot(page, `3-tune-running-${scheme}`); break; }
+    if (done) break;
+    await delay(600);
+  }
+  check(sawRun, `${scheme}: a step is shown as running`);
+  check(sawSpeed, `${scheme}: the live speed shows a number while it runs`);
+  if (sawSpeed) { fakePhase = 'done'; await page.locator('.tune-outcome').waitFor({ timeout: 15000 }).catch(() => {}); check(/18% faster/.test((await page.locator('.tune-outcome__body h3').textContent().catch(() => '')) ?? ''), `${scheme}: the result card shows the gain as its headline`); check(/Fast/.test((await page.locator('.tune-outcome__facts').textContent().catch(() => '')) ?? ''), `${scheme}: and what it was saved as`); }
+  await shot(page, `4-tune-result-${scheme}`);
+  await page.getByRole('button', { name: /^Close$/ }).first().click({ timeout: 10000 }).catch(() => {});
+  // a task: the opened task is skimmable, with pause / delete / Edit / Run now
+  const made = await api('/api/tasks', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ title: 'Open Downloads folder', prompt: 'Open my Downloads folder and tell me what is new.', frequency: 'weekdays', at: '08:00', weekday: 1, timeZone: 'Europe/Ljubljana', mode: 'manual', enabled: true }) });
+  const id = made.body?.id ?? made.body?.task?.id;
+  check(!!id, `${scheme}: a task is created`, JSON.stringify(made.body).slice(0, 120));
+  await page.evaluate(i => { location.hash = '#/tasks/' + i; }, id);
+  await page.getByRole('button', { name: /^Edit$/ }).first().waitFor({ timeout: 15000 });
+  console.log('info  header buttons', await page.getByRole('button', { name: /^Pause / }).count(), await page.getByRole('button', { name: /^Delete / }).count(), await page.getByRole('button', { name: /Run now/ }).count(), JSON.stringify(await page.locator('.task-header-actions button').evaluateAll(b => b.map(x => (x.getAttribute('aria-label') ?? x.textContent ?? '').trim()))));
+  check(await page.getByRole('button', { name: /^Pause / }).count() === 1 && await page.getByRole('button', { name: /^Delete / }).count() >= 1 && await page.getByRole('button', { name: /Run now/ }).count() >= 1, `${scheme}: pause, delete, Edit and Run now are in the header`);
+  check(await page.locator('.main__back').count() === 0 && await page.locator('.main__title-line .task-state').count() === 0, `${scheme}: nothing sits on the left of an opened task's navbar`);
+  const factsText = ((await page.locator('.task-facts').textContent()) ?? '').replace(/\s+/g, ' ');
+  check(/Weekdays/.test(factsText) && /Schedule/i.test(factsText) && /Last result/i.test(factsText), `${scheme}: schedule, what it may do and the last result are at the top`, factsText.slice(0, 160));
+  await shot(page, `5-task-${scheme}`);
+  await page.getByRole('button', { name: /^Pause / }).first().click();
+  await page.getByRole('button', { name: /^Resume / }).first().waitFor({ timeout: 10000 });
+  check(true, `${scheme}: Pause becomes Resume`);
+  check(page.problems.length === 0, `${scheme}: no page error`, page.problems.join('; '));
+});
+
+// ------------------------------------------------------------------------------------------------ tune + reading size
+await scenario('tune', { installed: true, env: { FAKE_TOKEN_DELAY: '0.02', FAKE_REPLY: ['I am thinking about it.', '</think>', '', 'Here is a list:', '', '- one', '- two', '', '## Heading', '', 'Some `code` and **bold** text.', '', '| a | b |', '|---|---|', '| 1 | 2 |', '', '```', 'code line', '```', ''].join(String.fromCharCode(10)) } }, async ({ base, api, browser, dirs, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /get started/i);
+  await page.getByText(/Choose a version/i).waitFor({ timeout: 30000 });
+  await page.locator('[role=radio]').filter({ hasText: 'IQ3_S' }).first().click();
+  await clickText(page, /^Continue/);
+  await page.getByText(/Leave 20% for my work/i).waitFor({ timeout: 30000 });
+  await delay(800);
+  await shot(page, '1-tune-step');
+  check(await page.getByText(/Read pictures when this model loads/i).count() === 0, 'the tuning step offers no picture reading for an app install');
+  await clickText(page, /Tune & start chatting/i);
+  let done = false, job = null;
+  for (let i = 0; i < 120 && !done; i++) { job = (await api('/api/native')).body.jobs.findLast?.(j => j.kind === 'tune') ?? null; done = !!job && job.state !== 'running'; await delay(1000); }
+  check(job?.state === 'done', 'tuning finishes without a vision error', job?.error ?? job?.state);
+  const cfg = JSON.parse(readFileSync(join(dirs.install, 'strata-iq3_s.json'), 'utf8'));
+  check(cfg.args.includes('--resident-budget-gib'), '"leave 20%" wrote a RAM budget for the experts', cfg.args.join(' '));
+  const gib = Number(cfg.args[cfg.args.indexOf('--resident-budget-gib') + 1]);
+  check(gib + 10 <= 63.1 * 0.8, 'the budget keeps the model within 80% of the PC RAM', `${gib} GiB`);
+  // chat + reading size
+  await page.getByRole('textbox', { name: /Message Strata/i }).waitFor({ timeout: 60000 });
+  await page.getByRole('textbox', { name: /Message Strata/i }).fill('hello');
+  await page.keyboard.press('Enter');
+  await page.locator('.st-msg--assistant .st-bubble').first().waitFor({ timeout: 60000 });
+  await page.locator('.st-msg--assistant .st-bubble p').first().waitFor({ timeout: 60000 }).catch(async () => console.log('info  reply so far:', JSON.stringify(await page.locator('.st-msg--assistant').first().innerText()).slice(0, 300)));
+  await page.waitForFunction(() => !document.querySelector('.st-msg--assistant .caret'), null, { timeout: 90000 }).catch(() => {});
+  // the chat's telemetry chips: speed and context
+  const chips = page.locator('.telemetry__chip');
+  const chipTexts = await chips.allInnerTexts();
+  console.log('info  chips', JSON.stringify(chipTexts));
+  let speedText = '', contextText = '';
+  for (let i = 0; i < await chips.count(); i++) {
+    await chips.nth(i).click();
+    await delay(400);
+    const pop = await page.locator('.telepop').last().innerText().catch(() => '');
+    if (/tok\/s|speed/i.test(pop) && !speedText) speedText = pop;
+    if (/context/i.test(pop) && !contextText) contextText = pop;
+    await page.keyboard.press('Escape');
+  }
+  const tps = Number(speedText.match(/([\d.]+)\s*tok(?:ens)?\/s/)?.[1] ?? NaN);
+  check(tps > 15 && tps < 120, 'the speed shown is the decode speed (the engine paced at ~50 tokens a second)', speedText.replace(/\s+/g, ' ').slice(0, 160));
+  check(/32\.8K|32K|32,768|32768/.test(contextText) && !/128K/.test(contextText), 'the context shown is the one the model runs with (32K), not 128K', contextText.replace(/\s+/g, ' ').slice(0, 160));
+  const sizes = [];
+  for (const px of [12, 14, 16, 22]) {
+    await page.evaluate(v => { const k = 'strata.prefs.v2'; const cur = JSON.parse(localStorage.getItem(k) || '{}'); localStorage.setItem(k, JSON.stringify({ ...cur, contentFontSize: v })); }, px);
+    await page.reload({ waitUntil: 'domcontentloaded' });
+    await page.locator('.st-msg--assistant .st-bubble').first().waitFor({ timeout: 30000 });
+    await page.screenshot({ path: join(shots, `tune-3-chat-${px}px.png`) });
+    sizes.push(await page.evaluate(() => { const b = document.querySelector('.st-msg--assistant .st-bubble'); const t = b.querySelector('p, .md-li, span') ?? b; const u = document.querySelector('.st-msg--user .st-bubble'); const all = {}; for (const el of b.querySelectorAll('*')) { if (!el.childNodes.length || ![...el.childNodes].some(n => n.nodeType === 3 && n.textContent.trim())) continue; all[el.tagName.toLowerCase() + (el.className ? '.' + String(el.className).split(' ')[0] : '')] = parseFloat(getComputedStyle(el).fontSize); } const extra = {}; for (const [k, q] of Object.entries({ reasoning: '.st-msg--assistant .st-collapse__body', codeblock: '.st-msg--assistant .st-code pre', codehead: '.st-msg--assistant .st-code__head' })) { const e = document.querySelector(q); if (e) extra[k] = parseFloat(getComputedStyle(e).fontSize); } Object.assign(all, extra); const chain = []; for (let e = b.querySelector('p'); e && e !== b; e = e.parentElement) chain.push(e.tagName + '.' + String(e.className).split(' ')[0] + '=' + getComputedStyle(e).fontSize); all.chain = chain; globalThis.__all = all; return [parseFloat(getComputedStyle(b).fontSize), parseFloat(getComputedStyle(t).fontSize), parseFloat(getComputedStyle(u).fontSize), all]; }));
+  }
+  console.log('info  chain', JSON.stringify(await page.evaluate(() => { const el = document.querySelector('.st-msg--assistant .st-bubble p'); const out = []; for (let e = el; e && !e.classList.contains('st-msg'); e = e.parentElement) out.push(e.tagName + '.' + String(e.className).split(' ')[0] + '=' + getComputedStyle(e).fontSize); return out; })));
+  // which visible text does NOT follow the reading size? (same elements at 12 and 22)
+  const survey = async px => { await page.evaluate(v => { const k = 'strata.prefs.v2'; const cur = JSON.parse(localStorage.getItem(k) || '{}'); localStorage.setItem(k, JSON.stringify({ ...cur, contentFontSize: v })); }, px); await page.reload({ waitUntil: 'domcontentloaded' }); await page.locator('.st-msg--assistant .st-bubble').first().waitFor({ timeout: 30000 }); await delay(600);
+    return page.evaluate(() => { const out = {}; for (const el of document.querySelectorAll('main *, .chat *, textarea')) { if (![...el.childNodes].some(n => n.nodeType === 3 && n.textContent.trim()) && el.tagName !== 'TEXTAREA') continue; const r = el.getBoundingClientRect(); if (!r.width || !r.height) continue; const key = el.tagName.toLowerCase() + '.' + String(el.className).split(' ')[0] + ' <' + (el.parentElement?.className ?? '').toString().split(' ')[0] + '>'; out[key] = parseFloat(getComputedStyle(el).fontSize); } return out; }); };
+  const a = await survey(12), b = await survey(22);
+  // a fresh app (nothing saved) uses 14 px
+  await page.evaluate(() => localStorage.removeItem('strata.prefs.v2'));
+  await page.reload({ waitUntil: 'domcontentloaded' });
+  await page.locator('.st-msg--assistant .st-bubble').first().waitFor({ timeout: 30000 });
+  check(await page.evaluate(() => getComputedStyle(document.querySelector('.st-msg--assistant .st-bubble')).fontSize) === '14px', 'the default reading size is 14 px');
+  const fixed = Object.keys(a).filter(k => k in b && a[k] === b[k]);
+  console.log('info  text that does not follow the reading size:', JSON.stringify(fixed.map(k => k + '=' + a[k])));
+  await shot(page, '2-chat-22px');
+  console.log('info  sizes', JSON.stringify(sizes), JSON.stringify(await page.locator('.st-msg--assistant .st-bubble').first().innerHTML()).slice(0, 400));
+  check(sizes[0][1] === 12 && sizes[1][1] === 14 && sizes[2][1] === 16 && sizes[3][1] === 22 && sizes[0][2] === 12 && sizes[3][2] === 22, 'the reading size changes the text size of the conversation', JSON.stringify(sizes));
+  // the slider itself
+  await page.evaluate(() => { location.hash = '#/chat?settings=1'; });
+  const slider = page.getByLabel('Reading text size');
+  if (await slider.count()) {
+    await slider.first().focus();
+    for (let i = 0; i < 4; i++) await page.keyboard.press('ArrowRight');
+    await delay(500);
+    const now = await page.evaluate(() => getComputedStyle(document.querySelector('.st-msg--assistant .st-bubble') ?? document.body).fontSize);
+    check(parseFloat(now) === 18, 'moving the slider changes the conversation text at once', now);
+    const box = await slider.first().boundingBox();
+    await page.mouse.click(box.x + box.width * 0.9, box.y + box.height / 2);
+    await delay(400);
+    const dragged = await page.evaluate(() => [getComputedStyle(document.querySelector('.st-msg--assistant .st-bubble') ?? document.body).fontSize, getComputedStyle(document.documentElement).getPropertyValue('--st-content-fs'), JSON.parse(localStorage.getItem('strata.prefs.v2') || '{}').contentFontSize]);
+    check(parseFloat(dragged[0]) >= 20 && parseFloat(dragged[2]) >= 20, 'clicking the slider with the mouse changes it too, and it is saved', dragged.join(' '));
+  } else console.log('info  the settings slider was not reachable by hash here; the stored size was checked above');
+  check(page.problems.length === 0, 'no page error', page.problems.join('; '));
+});
+
+// ------------------------------------------------------------------------------------------------ delete
+await scenario('delete', { installed: true }, async ({ base, api, browser, dirs, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByRole('button', { name: /^Load model$/ }).first().click();
+  let ready = false;
+  for (let i = 0; i < 90 && !ready; i++) { ready = (await api('/api/native')).body.instances.some(x => x.status === 'ready'); await delay(1000); }
+  check(ready, 'a model is loaded');
+  await clickText(page, /Manage models/i);
+  await page.getByRole('button', { name: /^Delete$/ }).first().click();
+  await delay(600);
+  await shot(page, '1-delete-confirm');
+  const dialog = await page.getByRole('dialog').last().innerText();
+  check(/Delete this version\?/.test(dialog) && /Remove 83\.6 GB of downloaded files\. You can download this version again\./.test(dialog), 'the confirm dialog uses the existing words and the real size', dialog.replace(/\s+/g, ' ').slice(0, 600));
+  check(/running model will be unloaded/i.test(dialog), 'and says the loaded model is unloaded first');
+  await page.getByRole('button', { name: /^Delete version$/ }).click();
+  let state = null;
+  for (let i = 0; i < 40; i++) { state = (await api('/api/native')).body; if (state.instances.length === 0 && !state.installed?.models?.some(m => m.model === 'iq3_s')) break; await delay(500); }
+  check(state.instances.length === 0, 'the loaded model was unloaded');
+  check(!existsSync(join(dirs.install, 'strata-iq3_s.json')), 'the installer removed the run config of the model');
+  check(!state.installed?.models?.some(m => m.model === 'iq3_s'), 'the model is no longer listed as downloaded');
+  await shot(page, '2-after-delete');
+});
+
+// ------------------------------------------------------------------------------------------------ perf
+await scenario('perf', { installed: true }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByRole('button', { name: /^Load model$/ }).first().click();
+  let ready = false;
+  for (let i = 0; i < 90 && !ready; i++) { ready = (await api('/api/native')).body.instances.some(x => x.status === 'ready'); await delay(1000); }
+  check(ready, 'a model is loaded');
+  await delay(2500);
+  const requests = [];
+  const started = new Map();
+  page.on('request', r => started.set(r, Date.now()));
+  page.on('requestfinished', r => requests.push([r.url().replace(base, '').slice(0, 60), Date.now() - (started.get(r) ?? Date.now())]));
+  await page.evaluate(() => { window.__long = []; new PerformanceObserver(l => { for (const e of l.getEntries()) window.__long.push(Math.round(e.duration)); }).observe({ entryTypes: ['longtask'] }); });
+  const t0 = Date.now();
+  await page.evaluate(() => { location.hash = '#/chat'; });
+  await page.getByRole('textbox', { name: /Message Strata/i }).waitFor({ timeout: 30000 });
+  const open = Date.now() - t0;
+  await delay(1500);
+  const long = await page.evaluate(() => window.__long);
+  console.log('info  chat opened in', open, 'ms; long tasks', JSON.stringify(long), 'requests', JSON.stringify(requests.filter(r => r[1] > 100)), 'all', requests.length);
+  check(open < 1500 && Math.max(0, ...long) < 300, 'Models to Chat opens at once, with no long block', open + ' ms, longest task ' + Math.max(0, ...long) + ' ms');
+});
+
+// ------------------------------------------------------------------------------------------------ polish
+await scenario('polish', { installed: true }, async ({ base, api, browser, dirs, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByText(/Conversation context/i).first().waitFor({ timeout: 30000 });
+  check(await page.getByRole('button', { name: /^Tune model$/ }).count() === 1, 'the Models tab has the Tune model button (the real tuner, not the old short benchmark)');
+  await clickText(page, /Manage models/i);
+  await delay(500);
+  const rows = await page.locator('.native-manage-row').count();
+  check(rows === 1, 'Manage models lists only the downloaded model, not the catalog', rows + ' row(s)');
+  await shot(page, '1-manage-models');
+  await page.getByRole('button', { name: /^Done$/ }).click();
+  await page.getByRole('button', { name: /Other local models/i }).click().catch(async () => { await clickText(page, /Manage models/i); await clickText(page, /Use a local GGUF/i); });
+  await page.getByText(/Folder with the GGUF files/i).first().waitFor({ timeout: 15000 }).catch(() => {});
+  await shot(page, '2-local-gguf');
+  check(await page.getByText(/Folder with the GGUF files/i).count() > 0, 'the local GGUF page opens in the same design as Models');
+  await page.getByPlaceholder(/Full path to the folder/i).fill(join(dirs.install, 'does-not-exist'));
+  await page.getByRole('button', { name: /^Check files$/ }).click();
+  await delay(3000);
+  check(await page.locator('.error-notice').count() > 0, 'a folder that cannot be used says so in words');
+  await shot(page, '2b-local-gguf-problem');
+  await page.evaluate(() => { location.hash = '#/chat?settings=1'; });
+  await delay(1500);
+  const text = await page.locator('body').innerText();
+  check(!/Contrast/.test(text), 'Settings has no Contrast option');
+  check(!/View request log/.test(text), 'and no "View request log" button');
+  await page.getByText(/^Engine$/).first().click().catch(() => {});
+  await delay(1500);
+  await shot(page, '3-settings-engine');
+  const engine = await page.locator('body').innerText();
+  check(/Update component/.test(engine) && /Diagnostics/.test(engine), 'Settings > Engine has Update component and Diagnostics');
+  check(!/Performance|Model settings|Calibrate|Engine installation/.test(engine), 'and nothing else');
+  await page.getByRole('button', { name: /^View logs$/ }).click();      // the logs open in a pop-up that holds Save logs
+  await page.getByRole('button', { name: /^Save logs$/ }).click();
+  await page.getByText(/Saved to/).first().waitFor({ timeout: 15000 }).catch(() => {});
+  const savedText = await page.getByText(/Saved to/).first().innerText().catch(() => '');
+  const savedPath = savedText.replace(/^Saved to\s*/, '').trim();
+  check(!!savedPath && existsSync(savedPath), 'Save logs writes a file to Downloads and says where', savedPath);
+  await shot(page, '4-logs-saved');
+  await page.evaluate(() => { location.hash = '#/monitor'; });
+  await delay(6000);
+  await shot(page, '5-monitor');
+  const mon = await page.locator('body').innerText();
+  check(/°C/.test(mon), 'the Monitor shows GPU data with no model loaded', (mon.match(/.{0,30}°C.{0,20}/)?.[0] ?? 'no temperature text').replace(/\s+/g, ' '));
+});
+
+// ------------------------------------------------------------------------------------------------ stop
+await scenario('stop', { installed: true, env: { FAKE_TOKEN_DELAY: '0.1', FAKE_REPLY: 'thinking '.repeat(30) } }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /Go straight to the app/i);
+  await page.waitForURL(/#\/models/, { timeout: 15000 }).catch(() => {});
+  await page.getByRole('button', { name: /^Load model$/ }).first().click();
+  let ready = false;
+  for (let i = 0; i < 90 && !ready; i++) { ready = (await api('/api/native')).body.instances.some(x => x.status === 'ready'); await delay(1000); }
+  if (!ready) { const st = (await api('/api/native')).body; console.log('info  jobs', JSON.stringify(st.jobs.map(j => [j.kind, j.state, j.error ?? j.summary])), JSON.stringify(st.instances.map(i => [i.status, i.error]))); await shot(page, '0-stop-notloaded'); }
+  check(ready, 'a model is loaded');
+  await page.evaluate(() => { location.hash = '#/chat'; });
+  const box = page.getByRole('textbox', { name: /Message Strata/i });
+  await box.waitFor({ timeout: 30000 });
+  await box.fill('hello');
+  await page.keyboard.press('Enter');
+  await page.locator('.typing').first().waitFor({ timeout: 30000 });
+  await delay(1500);
+  await page.getByRole('button', { name: /^Stop/i }).first().click().catch(async () => { await page.keyboard.press('Escape'); });
+  await delay(4000);
+  const dots = await page.locator('.typing').count();
+  await shot(page, '1-after-stop');
+  check(dots === 0, 'after Stop in the middle of thinking the three dots are gone', dots + ' left');
+});
+
+// ------------------------------------------------------------------------------------------------ latest
+await scenario('latest', {}, async ({ base, browser, shot }) => {
+  const page = await newPage(browser, base);
+  const now = Date.now();
+  await page.evaluate(now => {
+    const messages = [];
+    for (let i = 0; i < 40; i++) { messages.push({ id: 'u' + i, role: 'user', content: 'question ' + i, at: now }, { id: 'a' + i, role: 'assistant', content: 'answer number ' + i + ' with some text to fill the line and more of it.', at: now, tokens: 20, inputTokens: 5 }); }
+    localStorage.setItem('strata.sessions.v1', JSON.stringify([{ id: 's_latest', title: 'long', updatedAt: now, createdAt: now, messages }]));
+    localStorage.setItem('strata.active-session.v1', 's_latest');
+  }, now);
+  await page.reload({ waitUntil: 'domcontentloaded' });
+  await delay(1500);
+  if (await page.getByRole('button', { name: /Go straight to the app/i }).count()) { await clickText(page, /Go straight to the app/i); await delay(1500); }
+  await page.goto(base + '/#/chat', { waitUntil: 'domcontentloaded' });
+  await page.getByRole('textbox', { name: /Message Strata/i }).waitFor({ timeout: 30000 });
+  await delay(800);
+  await page.locator('.main__body.chat').first().waitFor({ timeout: 15000 }).catch(async () => { await shot(page, '0-latest-missing'); console.log('info  body', JSON.stringify((await page.locator('body').innerText()).slice(0, 300))); });
+  await page.locator('.main__body.chat').first().evaluate(el => { el.scrollTop = 3000; });
+  await delay(600);
+  await page.mouse.wheel(0, -400);
+  await delay(600);
+  await page.locator('.main__body.chat').first().evaluate(el => { el.scrollTop = 0; });
+  await delay(800);
+  const gaps = await page.evaluate(() => { const b = document.querySelector('.jumplatest'), c = document.querySelector('.main__body.chat'); if (!b || !c) return null; const r = b.getBoundingClientRect(), cr = c.getBoundingClientRect(); return { top: Math.round(r.top - cr.top), bottom: Math.round(cr.bottom - r.bottom) }; });
+  console.log('info  chat dom', JSON.stringify(await page.evaluate(() => { const c = document.querySelector('.main__body.chat'); return { msgs: document.querySelectorAll('.st-msg').length, scrollH: c?.scrollHeight, clientH: c?.clientHeight, top: c?.scrollTop, jump: document.querySelectorAll('.jumplatest').length }; })));
+  await shot(page, '1-latest-button');
+  check(!!gaps && gaps.top >= 12 && gaps.bottom >= 12, 'the Latest button keeps a gap from the top navigation and from the bottom', JSON.stringify(gaps));
+});
+
+// ------------------------------------------------------------------------------------------------ fail
+await scenario('fail', { installed: true, env: { FAKE_ENGINE_FAIL: '1' } }, async ({ base, api, browser, shot }) => {
+  const page = await newPage(browser, base);
+  await clickText(page, /get started/i);
+  await page.getByText(/Choose a version/i).waitFor({ timeout: 30000 });
+  await page.locator('[role=radio]').filter({ hasText: 'IQ3_S' }).first().click();
+  await clickText(page, /^Continue/);
+  await clickText(page, /Tune & start chatting/i, 30000);
+  await page.getByText(/ran low on memory/i).first().waitFor({ timeout: 120000 });
+  await delay(1000);
+  await shot(page, '1-tune-error');
+  const text = await page.locator('.guided-onboarding').innerText();
+  check(/ran low on memory/.test(text), 'the error says in words that the PC ran low on memory');
+  check(/Leave 20% for my work/.test(text) && /low-RAM/.test(text), 'and what to try');
+  check(!/server_exited|memory guard/.test(text), 'no code or log line in the main text');
+  check(!/vision files/i.test(text), 'no picture-reading error');
+  const bad = await noScroll(page);
+  check(bad.length === 0, 'the tuning pop-up does not scroll when an error shows', bad.join('; '));
+  await page.locator('.error-notice summary').first().click();
+  await delay(500);
+  await shot(page, '2-tune-error-details');
+  const details = await page.locator('.error-notice pre').first().innerText();
+  check(/server_exited/.test(details) && /exited before/.test(details), 'Details holds the code and the reason the server logged', details.replace(/\s+/g, ' ').slice(0, 120));
+  const badOpen = await noScroll(page);
+  check(badOpen.length === 0, 'and the pop-up still does not scroll with Details open', badOpen.join('; '));
+  await page.setViewportSize({ width: 1280, height: 700 });
+  await delay(600);
+  const small = await noScroll(page);
+  check(small.length === 0, 'nor in a small window (1280x700), Details open', small.join('; '));
+  await shot(page, '3-tune-error-small-window');
+  void api;
+});
+
+// ------------------------------------------------------------------------------------------------ restart
+// The app keeps its theme, text size, language and chat list in the browser's storage, which belongs to the window's origin
+// (127.0.0.1:<port>). The shell now uses the same port every launch: stop the host, start it again on that port, reopen the
+// window with the same browser profile, and everything is still there.
+if (only.has('restart')) {
+  console.log('--- restart');
+  const fixed = await freePort();
+  const profile = join(work, 'browser-profile');
+  const run = async (body) => scenario('restart', { env: { FIXED_PORT: String(fixed) } }, async ctx => {
+    const context = await chromium.launchPersistentContext(profile, { executablePath: CHROME, headless: true, viewport: { width: 1200, height: 800 } });
+    try { await body(context, ctx); } finally { await context.close(); }
+  });
+  only.add('restart');
+  await run(async (context, { base }) => {
+    const page = context.pages()[0] ?? await context.newPage();
+    await page.goto(base, { waitUntil: 'domcontentloaded' });
+    await page.evaluate(() => { localStorage.setItem('strata.prefs.v2', JSON.stringify({ theme: 'dark', contentFontSize: 19, language: 'de' })); localStorage.setItem('strata.sessions.v1', JSON.stringify([{ id: 'chat-1', title: 'My chat' }])); });
+  });
+  await run(async (context, { base }) => {
+    const page = context.pages()[0] ?? await context.newPage();
+    await page.goto(base, { waitUntil: 'domcontentloaded' });
+    const saved = await page.evaluate(() => ({ prefs: JSON.parse(localStorage.getItem('strata.prefs.v2') || '{}'), chats: localStorage.getItem('strata.sessions.v1'), theme: document.documentElement.dataset.theme }));
+    check(saved.prefs.contentFontSize === 19 && saved.prefs.language === 'de', 'text size and language survive a restart on the same port', JSON.stringify(saved.prefs));
+    check(saved.theme === 'dark', 'the theme survives too', saved.theme);
+    check(/My chat/.test(saved.chats ?? ''), 'and the chat list', saved.chats);
+  });
+}
+
+// ------------------------------------------------------------------------------------------------ theme
+await scenario('theme', {}, async ({ base, browser, shot }) => {
+  for (const scheme of ['dark', 'light']) {
+    const page = await newPage(browser, base, { colorScheme: scheme });
+    await delay(1500);
+    const theme = await page.evaluate(() => document.documentElement.dataset.theme);
+    check(theme === scheme, `a fresh app follows the system (${scheme})`, theme);
+    await shot(page, `1-${scheme}`);
+    await page.context().close();
+  }
+});
+
+// the junctions into the staged Control go first (rmdir on a junction removes only the link)
+for (const name of ['python', 'strata_control', 'strata_cli', 'serve']) { try { rmdirSync(join(control, name)); } catch { /* already gone */ } }
+try { rmSync(work, { recursive: true, force: true, maxRetries: 3 }); } catch (e) { console.log('info  scratch folder left behind:', work); }
+console.log(`shots in ${shots}`);
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * Picture reading in the APP, end to end on a test box, through the installed app layout (packaged host + bundled Control + a real engine component
+ * that carries strata-vision):
+ *   Download and prepare with "Read pictures" ON (the picture-reader file is fetched, the vision settings are written), load the model with the picture
+ *   reader, send a real picture through the host's own /v1 endpoint and check that the answer names what is in it, unload, shut down.
+ *
+ *   node vision-e2e.mjs --install <folder with node/ host/ control/> --components <folder holding engine/<package with strata-vision>> \
+ *        --work <scratch> --family qwen --model IQ3_XXS --data <data folder that has (or will get) the model files> --image shapes.png [--device cpu|gpu]
+ *
+ * The picture has a red circle, a blue square, a green triangle and the text "STRATA 42". The run exits 1 if any step fails.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { join, resolve } from 'node:path';
+
+const args = Object.fromEntries(process.argv.slice(2).reduce((acc, a, i, all) => (a.startsWith('--') ? [...acc, [a.slice(2), all[i + 1]?.startsWith('--') || all[i + 1] === undefined ? true : all[i + 1]]] : acc), []));
+for (const need of ['install', 'components', 'work', 'model', 'image']) if (!args[need]) { console.error('missing --' + need); process.exit(2); }
+const install = resolve(args.install), work = resolve(args.work), components = resolve(args.components), family = String(args.family ?? 'qwen'), modelId = String(args.model);
+const device = String(args.device ?? 'cpu');
+const node = join(install, 'node', 'node'), hostEntry = join(install, 'host', 'server', 'index.mjs'), controlDir = join(install, 'control');
+const dirs = { models: join(work, 'models'), profiles: join(work, 'profiles'), runtime: join(work, 'runtime'), home: join(work, 'home'), xdg: join(work, 'xdg'), appdata: join(work, 'appdata') };
+for (const d of [dirs.models, dirs.home, dirs.xdg, dirs.appdata]) mkdirSync(d, { recursive: true });
+const delay = ms => new Promise(r => setTimeout(r, ms));
+let failed = false;
+const record = (name, ok, detail = '') => { if (!ok) failed = true; console.log(`${ok ? 'ok  ' : 'FAIL'} ${name}${detail ? '  ' + String(detail).slice(0, 600) : ''}`); };
+const freePort = async () => { const s = createServer(); await new Promise(r => s.listen(0, '127.0.0.1', r)); const p = s.address().port; await new Promise(r => s.close(r)); return p; };
+const env = { ...process.env, STRATA_COMPONENTS_DIR: components, STRATA_PROFILE_DIR: dirs.profiles, STRATA_RUNTIME_DIR: dirs.runtime, STRATA_INSTALL_DIR: dirs.models,
+  STRATA_HOME: dirs.home, STRATA_MODELS_DIR: join(work, 'models-unused'), APPDATA: dirs.appdata, XDG_CONFIG_HOME: dirs.xdg, PYTHONDONTWRITEBYTECODE: '1' };
+delete env.STRATA_API_KEY;
+const port = await freePort();
+const base = `http://127.0.0.1:${port}`;
+const host = spawn(node, [hostEntry], { cwd: join(install, 'host'), stdio: ['ignore', 'pipe', 'pipe'],
+  env: { ...env, STRATA_PORT: String(port), STRATA_DIST: join(install, 'host', 'dist'), NODE_ENV: 'production', STRATA_PACKAGED: '1', STRATA_REAL_ENGINE: '1', STRATA_NO_ACQUIRE: '1',
+    STRATA_SHARE_PORT: String(await freePort()), STRATA_TUNNEL_PORT: String(await freePort()) } });
+let hostLog = '';
+host.stdout.on('data', c => { hostLog += c; }); host.stderr.on('data', c => { hostLog += c; });
+const call = async (path, method = 'GET', body) => {
+  const response = await fetch(base + path, { method, headers: { 'content-type': 'application/json' }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: response.status, body: await response.json().catch(() => null) };
+};
+async function waitJob(id, seconds) {
+  let last = '';
+  for (let i = 0; i < seconds * 2; i++) {
+    const state = (await call('/api/native')).body;
+    const job = state.jobs.find(j => j.id === id);
+    if (job && job.summary !== last) { last = job.summary; console.log('    ... ' + String(last).slice(0, 120)); }
+    if (job && job.state !== 'running') return { job, state };
+    await delay(500);
+  }
+  throw new Error('operation did not finish');
+}
+async function main() {
+  let up = false;
+  for (let i = 0; i < 200 && !up; i++) { try { up = (await fetch(base + '/api/health')).ok; } catch { /* not yet */ } if (!up) await delay(150); }
+  record('host healthy', up, up ? base : hostLog.slice(-500));
+  if (!up) return;
+  const packages = existsSync(join(components, 'engine')) ? readdirSync(join(components, 'engine')) : [];
+  const reader = packages.some(p => existsSync(join(components, 'engine', p, 'strata-vision')));
+  record('the engine component carries the picture reader (strata-vision)', reader, packages.join(', '));
+  const status = (await call('/api/control/status')).body;
+  record('Control: engine usable', status.engine?.usable === true, `engine=${status.engine?.engine?.version}`);
+
+  // ---- Download and prepare, "Read pictures" on (the app sends vision "yes" for the download)
+  const values = { family, model: modelId, context: 32768, vision: 'yes', loadVision: device, ...(args.data ? { data_dir: resolve(args.data) } : {}) };
+  const plan = await call('/api/native/plan', 'POST', values);
+  record('the plan for the download is made', plan.status === 200, JSON.stringify(plan.body).slice(0, 300));
+  const started = await call('/api/native/operations', 'POST', { kind: 'install', args: values });
+  record('the install operation starts', started.status === 200 || started.status === 202, JSON.stringify(started.body).slice(0, 200));
+  const done = await waitJob(started.body.id, 3600);
+  record('Download and prepare finishes', done.job.state === 'done', `${done.job.state} ${done.job.error ?? done.job.summary}`);
+  const native = (await call('/api/native?refresh=1')).body;
+  console.log('    installed models: ' + JSON.stringify((native.installed?.models ?? []).map(m => ({ id: m.id, model: m.model, ready: m.ready, visionPrepared: m.visionPrepared, images: m.images, config: m.config }))));
+  const want = modelId.toLowerCase();
+  const model = native.installed?.models?.find(m => [m.id, m.model, m.tag].some(x => String(x ?? '').toLowerCase() === want));
+  record('the model is installed with the picture reader prepared (visionPrepared)', !!model?.visionPrepared, JSON.stringify({ ready: model?.ready, visionPrepared: model?.visionPrepared, images: model?.images }));
+  const configFile = model?.configPath ?? (model?.config ? join(dirs.models, model.config) : null);
+  let cfg = {};
+  try { cfg = JSON.parse(readFileSync(configFile, 'utf8')); } catch { /* reported below */ }
+  const mm = cfg.vision?.mmproj;
+  record('the run settings carry the vision entry and --vision, and the mmproj file is on disk',
+    !!cfg.vision && (cfg.args ?? []).includes('--vision') && !!mm && existsSync(mm) && statSync(mm).size > 800e6,
+    `vision=${cfg.vision ? 'yes' : 'no'} --vision=${(cfg.args ?? []).includes('--vision')} mmproj=${mm ? Math.round(statSync(mm).size / 1048576) + ' MB' : 'none'}`);
+
+  // ---- load with the picture reader
+  const load = await call('/api/native/operations', 'POST', { kind: 'load', args: { model: model?.model ?? modelId.toLowerCase(), vision: device } });
+  const loaded = await waitJob(load.body.id, 900);
+  const instance = loaded.state.instances[0];
+  record('load starts the engine with the picture reader', loaded.job.state === 'done' && instance?.status === 'ready', `${loaded.job.state} ${loaded.job.error ?? ''}; instance=${instance?.status}; vision=${instance?.vision}`);
+  record('the host says the loaded model reads pictures', !!instance?.vision, `vision=${instance?.vision}`);
+
+  // ---- a real picture through the host's own /v1 endpoint
+  const png = readFileSync(resolve(args.image)).toString('base64');
+  const t = Date.now();
+  let answer = '', finish = '';
+  for (const budget of [1536, 4096]) {
+    const chat = await call('/v1/chat/completions', 'POST', { model: instance?.apiModelId ?? modelId, max_tokens: budget, stream: false, messages: [{ role: 'user', content: [
+      { type: 'text', text: 'Describe this picture: name each shape with its colour and read out any text.' },
+      { type: 'image_url', image_url: { url: 'data:image/png;base64,' + png } }] }] });
+    const choice = chat.body?.choices?.[0] ?? {};
+    answer = choice.message?.content ?? '';
+    finish = choice.finish_reason ?? String(chat.status);
+    if (answer.trim() || finish !== 'length') break;
+  }
+  console.log(`    answer (${Math.round((Date.now() - t) / 1000)} s, finish=${finish}): ${JSON.stringify(answer.slice(0, 300))}`);
+  const low = answer.toLowerCase();
+  record('the answer names the red circle', /red|circle/.test(low));
+  record('the answer names the blue square', /blue|square/.test(low));
+  record('the answer names the green triangle', /green|triangle/.test(low));
+  record('the answer reads STRATA 42', low.includes('42'));
+
+  // ---- unload
+  const unloaded = await call(`/api/native/instances/${instance?.id}/unload`, 'POST', {});
+  record('unload', unloaded.status === 200, unloaded.status);
+}
+try { await main(); } catch (e) { record('run', false, e.stack ?? e); }
+host.kill();
+await delay(1500);
+console.log(failed ? 'VISION-E2E FAIL' : 'VISION-E2E PASS');
+process.exit(failed ? 1 : 0);
@@ -0,0 +1,2 @@
+# Rust build output. Regenerated by `cargo tauri build`; never committed.
+/target/
@@ -0,0 +1,32 @@
+[package]
+name = "strata-desktop"
+version = "0.2.7"
+description = "Strata Desktop — local AI, tuned to one model."
+edition = "2021"
+rust-version = "1.77"
+license = "MIT"
+
+# Linux: the drop of a file on the window is read straight from the GTK drag signals (see hook_linux_drops in main.rs); the versions are the ones Tauri itself uses.
+[target.'cfg(target_os = "linux")'.dependencies]
+gtk = "0.18"
+webkit2gtk = "2.0"
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = ["tray-icon", "image-png"] }
+tauri-plugin-shell = "2"
+# Desktop notifications for an approval that waits (#3477); the tray icon above is Tauri's own.
+tauri-plugin-notification = "2"
+tauri-plugin-updater = "2"
+tauri-plugin-single-instance = "2"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[profile.release]
+codegen-units = 1
+lto = true
+opt-level = "s"
+panic = "abort"
+strip = true
@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <!-- Tauri uses the system WKWebView, so this bundle needs no JIT entitlement of its own;
+       the web content process gets what it needs from the OS. The App Host runs as an ordinary
+       child process and needs no special rights. Kept minimal on purpose. -->
+  <key>com.apple.security.files.user-selected.read-write</key>
+  <true/>
+  <key>com.apple.security.network.client</key>
+  <true/>
+  <key>com.apple.security.network.server</key>
+  <true/>
+</dict>
+</plist>
@@ -0,0 +1 @@
+{"core":{"default_permission":{"identifier":"default","description":"Default core plugins set.","permissions":["core:path:default","core:event:default","core:window:default","core:webview:default","core:app:default","core:image:default","core:resources:default","core:menu:default","core:tray:default"]},"permissions":{},"permission_sets":{},"global_scope_schema":null},"core:app":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-version","allow-name","allow-tauri-version","allow-identifier","allow-bundle-type","allow-register-listener","allow-remove-listener","allow-supports-multiple-windows"]},"permissions":{"allow-app-hide":{"identifier":"allow-app-hide","description":"Enables the app_hide command without any pre-configured scope.","commands":{"allow":["app_hide"],"deny":[]}},"allow-app-show":{"identifier":"allow-app-show","description":"Enables the app_show command without any pre-configured scope.","commands":{"allow":["app_show"],"deny":[]}},"allow-bundle-type":{"identifier":"allow-bundle-type","description":"Enables the bundle_type command without any pre-configured scope.","commands":{"allow":["bundle_type"],"deny":[]}},"allow-default-window-icon":{"identifier":"allow-default-window-icon","description":"Enables the default_window_icon command without any pre-configured scope.","commands":{"allow":["default_window_icon"],"deny":[]}},"allow-exit":{"identifier":"allow-exit","description":"Enables the exit command without any pre-configured scope.","commands":{"allow":["exit"],"deny":[]}},"allow-fetch-data-store-identifiers":{"identifier":"allow-fetch-data-store-identifiers","description":"Enables the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":["fetch_data_store_identifiers"],"deny":[]}},"allow-identifier":{"identifier":"allow-identifier","description":"Enables the identifier command without any pre-configured scope.","commands":{"allow":["identifier"],"deny":[]}},"allow-name":{"identifier":"allow-name","description":"Enables the name command without any pre-configured scope.","commands":{"allow":["name"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-data-store":{"identifier":"allow-remove-data-store","description":"Enables the remove_data_store command without any pre-configured scope.","commands":{"allow":["remove_data_store"],"deny":[]}},"allow-remove-listener":{"identifier":"allow-remove-listener","description":"Enables the remove_listener command without any pre-configured scope.","commands":{"allow":["remove_listener"],"deny":[]}},"allow-set-app-theme":{"identifier":"allow-set-app-theme","description":"Enables the set_app_theme command without any pre-configured scope.","commands":{"allow":["set_app_theme"],"deny":[]}},"allow-set-dock-visibility":{"identifier":"allow-set-dock-visibility","description":"Enables the set_dock_visibility command without any pre-configured scope.","commands":{"allow":["set_dock_visibility"],"deny":[]}},"allow-supports-multiple-windows":{"identifier":"allow-supports-multiple-windows","description":"Enables the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":["supports_multiple_windows"],"deny":[]}},"allow-tauri-version":{"identifier":"allow-tauri-version","description":"Enables the tauri_version command without any pre-configured scope.","commands":{"allow":["tauri_version"],"deny":[]}},"allow-version":{"identifier":"allow-version","description":"Enables the version command without any pre-configured scope.","commands":{"allow":["version"],"deny":[]}},"deny-app-hide":{"identifier":"deny-app-hide","description":"Denies the app_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["app_hide"]}},"deny-app-show":{"identifier":"deny-app-show","description":"Denies the app_show command without any pre-configured scope.","commands":{"allow":[],"deny":["app_show"]}},"deny-bundle-type":{"identifier":"deny-bundle-type","description":"Denies the bundle_type command without any pre-configured scope.","commands":{"allow":[],"deny":["bundle_type"]}},"deny-default-window-icon":{"identifier":"deny-default-window-icon","description":"Denies the default_window_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["default_window_icon"]}},"deny-exit":{"identifier":"deny-exit","description":"Denies the exit command without any pre-configured scope.","commands":{"allow":[],"deny":["exit"]}},"deny-fetch-data-store-identifiers":{"identifier":"deny-fetch-data-store-identifiers","description":"Denies the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":[],"deny":["fetch_data_store_identifiers"]}},"deny-identifier":{"identifier":"deny-identifier","description":"DenLine truncated
@@ -0,0 +1 @@
+{}
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>
@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="ic_launcher_background">#FFFFFF</color>
+</resources>
				`@@ -0,0 +1 @@`
				{"core":{"default_permission":{"identifier":"default","description":"Default core plugins set.","permissions":["core:path:default","core:event:default","core:window:default","core:webview:default","core:app:default","core:image:default","core:resources:default","core:menu:default","core:tray:default"]},"permissions":{},"permission_sets":{},"global_scope_schema":null},"core:app":{"default_permission":{"identifier":"default","description":"Default permissions for the plugin.","permissions":["allow-version","allow-name","allow-tauri-version","allow-identifier","allow-bundle-type","allow-register-listener","allow-remove-listener","allow-supports-multiple-windows"]},"permissions":{"allow-app-hide":{"identifier":"allow-app-hide","description":"Enables the app_hide command without any pre-configured scope.","commands":{"allow":["app_hide"],"deny":[]}},"allow-app-show":{"identifier":"allow-app-show","description":"Enables the app_show command without any pre-configured scope.","commands":{"allow":["app_show"],"deny":[]}},"allow-bundle-type":{"identifier":"allow-bundle-type","description":"Enables the bundle_type command without any pre-configured scope.","commands":{"allow":["bundle_type"],"deny":[]}},"allow-default-window-icon":{"identifier":"allow-default-window-icon","description":"Enables the default_window_icon command without any pre-configured scope.","commands":{"allow":["default_window_icon"],"deny":[]}},"allow-exit":{"identifier":"allow-exit","description":"Enables the exit command without any pre-configured scope.","commands":{"allow":["exit"],"deny":[]}},"allow-fetch-data-store-identifiers":{"identifier":"allow-fetch-data-store-identifiers","description":"Enables the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":["fetch_data_store_identifiers"],"deny":[]}},"allow-identifier":{"identifier":"allow-identifier","description":"Enables the identifier command without any pre-configured scope.","commands":{"allow":["identifier"],"deny":[]}},"allow-name":{"identifier":"allow-name","description":"Enables the name command without any pre-configured scope.","commands":{"allow":["name"],"deny":[]}},"allow-register-listener":{"identifier":"allow-register-listener","description":"Enables the register_listener command without any pre-configured scope.","commands":{"allow":["register_listener"],"deny":[]}},"allow-remove-data-store":{"identifier":"allow-remove-data-store","description":"Enables the remove_data_store command without any pre-configured scope.","commands":{"allow":["remove_data_store"],"deny":[]}},"allow-remove-listener":{"identifier":"allow-remove-listener","description":"Enables the remove_listener command without any pre-configured scope.","commands":{"allow":["remove_listener"],"deny":[]}},"allow-set-app-theme":{"identifier":"allow-set-app-theme","description":"Enables the set_app_theme command without any pre-configured scope.","commands":{"allow":["set_app_theme"],"deny":[]}},"allow-set-dock-visibility":{"identifier":"allow-set-dock-visibility","description":"Enables the set_dock_visibility command without any pre-configured scope.","commands":{"allow":["set_dock_visibility"],"deny":[]}},"allow-supports-multiple-windows":{"identifier":"allow-supports-multiple-windows","description":"Enables the supports_multiple_windows command without any pre-configured scope.","commands":{"allow":["supports_multiple_windows"],"deny":[]}},"allow-tauri-version":{"identifier":"allow-tauri-version","description":"Enables the tauri_version command without any pre-configured scope.","commands":{"allow":["tauri_version"],"deny":[]}},"allow-version":{"identifier":"allow-version","description":"Enables the version command without any pre-configured scope.","commands":{"allow":["version"],"deny":[]}},"deny-app-hide":{"identifier":"deny-app-hide","description":"Denies the app_hide command without any pre-configured scope.","commands":{"allow":[],"deny":["app_hide"]}},"deny-app-show":{"identifier":"deny-app-show","description":"Denies the app_show command without any pre-configured scope.","commands":{"allow":[],"deny":["app_show"]}},"deny-bundle-type":{"identifier":"deny-bundle-type","description":"Denies the bundle_type command without any pre-configured scope.","commands":{"allow":[],"deny":["bundle_type"]}},"deny-default-window-icon":{"identifier":"deny-default-window-icon","description":"Denies the default_window_icon command without any pre-configured scope.","commands":{"allow":[],"deny":["default_window_icon"]}},"deny-exit":{"identifier":"deny-exit","description":"Denies the exit command without any pre-configured scope.","commands":{"allow":[],"deny":["exit"]}},"deny-fetch-data-store-identifiers":{"identifier":"deny-fetch-data-store-identifiers","description":"Denies the fetch_data_store_identifiers command without any pre-configured scope.","commands":{"allow":[],"deny":["fetch_data_store_identifiers"]}},"deny-identifier":{"identifier":"deny-identifier","description":"DenLine truncated