diff --git a/docs/dcc-submitters.md b/docs/dcc-submitters.md
index 18898309..9facebe9 100644
--- a/docs/dcc-submitters.md
+++ b/docs/dcc-submitters.md
@@ -230,17 +230,21 @@ enforcement point, and the submitter must not break against an older server.
 
 ## Reference presets
 
-sqi ships six DCC reference products under `presets/sqi/`, published through
+sqi ships nine DCC reference products under `presets/sqi/`, published through
 the [preset library](preset-library.md) so `sqi-submitter` has something real
-to submit to out of the box (the directory holds eleven products in total —
+to submit to out of the box (the directory holds fourteen products in total —
 the other five are `Transcoding`-category ffmpeg presets; see [Transcoding
 reference presets](preset-library.md#transcoding-reference-presets)). Install
 them from **Admin → Preset Library** in the web UI, or by hand via `POST
 /api/v1/products` (or **Admin → Products** in the web UI) if you're not using
 a preset index. All use the product `category`
-`Rendering` and declare `TASK_CHUNKING` for frame distribution; the Maya and
-Blender presets additionally declare `SQI_CHUNK_BOUNDS` to expose each chunk's
-start/end frame (see [OpenJD extensions](openjd-extensions.md)).
+`Rendering` and declare `TASK_CHUNKING` for frame distribution; the Maya,
+Blender and Mistika presets additionally declare `SQI_CHUNK_BOUNDS` to expose
+each chunk's start/end frame (see [OpenJD extensions](openjd-extensions.md)).
+
+Six of the nine have a matching `sqi-submitter` host (Maya, Houdini, Nuke,
+Blender). The three Mistika presets do not — Mistika has no in-DCC submitter,
+so they are submitted from the web UI or the API like any other product.
 
 | Product | Command | Chunking | Parameters | Worker tag |
 |---|---|---|---|---|
@@ -250,6 +254,9 @@ start/end frame (see [OpenJD extensions](openjd-extensions.md)).
 | `nuke-write-render` | `nuke -x -X <writeNode> -F <range> <script>` | chunks of 10 | `SceneFile`, `Frames`, `WriteNode` | `attr.worker.tag.nuke = "true"` |
 | `nuke-script-render` | `nuke -x -F <range> <script>` (no `-X`; all enabled Write nodes) | chunks of 10 | `SceneFile`, `Frames` | `attr.worker.tag.nuke = "true"` |
 | `blender-batch-render` | `blender -b <file> -o <output> -s/-e <frame range> -a` | one frame per task by default (raise the chunk size to batch) | `SceneFile`, `Frames`, `OutputPath` (optional; blank = scene setting) | `attr.worker.tag.blender = "true"` |
+| `mistika-boutique-render` | `mistika -r <scene> -s/-e <frame range>` | chunks of 10 | `SceneFile` (`*.rnd`), `Frames` | `attr.worker.tag.mistika = "true"` |
+| `mistika-vr-render` | `vr -r <scene> -s/-e <frame range>` | chunks of 10 | `SceneFile` (`*.rnd`), `Frames` | `attr.worker.tag.mistikavr = "true"` |
+| `mistika-workflows-render` | `workflows -r <scene> -s/-e <frame range>` | chunks of 10 | `SceneFile` (`*.rnd`), `Frames` | `attr.worker.tag.mistikaworkflows = "true"` |
 
 Maya and Nuke each ship two variants: a **single-target** product (`-rl <layer>` /
 `-X <writeNode>`) and a **whole-scene** product that omits that flag — Maya's
@@ -265,18 +272,33 @@ Nuke instead get multi-frame chunks (10 by default) natively, because both the
 embedded `hython` script and `nuke -F` accept a frame range per invocation, so a
 chunk amortizes DCC startup cost across several frames.
 
+The three Mistika presets use `SQI_CHUNK_BOUNDS` the same way Maya and Blender
+do, but batch by default (chunks of 10): every Mistika renderer takes `-s
+START -e END`, so a chunk maps directly onto one invocation. All three render
+`.rnd` job files. For a single movie-file render, submit `Frames` as `1`.
+
 Each preset's `hostRequirements` gates it to workers advertising the matching
 `attr.worker.tag.<name>` capability tag. `sqi-worker` auto-detects a standard
-Maya/Nuke/Houdini/Blender install on `PATH`/in its usual install location and
-advertises the matching tag (`maya`, plus a version variant like `maya-2025`)
-with value `"true"` automatically at startup, with no configuration — see
-[Capability
+Maya/Nuke/Houdini/Blender/Mistika install on `PATH`/in its usual install
+location and advertises the matching tag (`maya`, plus a version variant like
+`maya-2025`) with value `"true"` automatically at startup, with no
+configuration — see [Capability
 auto-detection](worker-capabilities.md#capability-auto-detection-built-in-dcc-detectors).
-That satisfies the `anyOf: ["true"]` requirement each of the six presets above
+That satisfies the `anyOf: ["true"]` requirement each of the nine presets above
 declares, so a worker with a standard DCC install matches these presets with
 **zero per-worker configuration**. Run `sqi-worker capabilities` (or
 `start --dry-run`) to confirm at a glance which DCCs were actually found.
 
+**The Mistika detectors probe install locations only, never `PATH`.** The
+binaries are named `mistika`, `vr` and `workflows`; the last two are generic
+enough that a `PATH` probe would tag workers with no Mistika installed, and a
+falsely tagged worker is handed render work it cannot run. The trade-off is
+that detection and execution use different evidence: a worker is tagged
+because Mistika is *installed* under the SGO layout, but the preset invokes
+the bare command, so the binary must also be on the worker's `PATH`. If your
+SGO install is not on `PATH`, either add it or duplicate the preset and give
+`command:` an absolute path.
+
 Manual tags are only needed when a DCC lives at a nonstandard install path (or
 under a name/location the built-in detectors don't check) or for in-house
 tools the built-in detectors don't cover. In those cases, add a `key=value`
diff --git a/docs/development.md b/docs/development.md
index 2278c6be..38cade52 100644
--- a/docs/development.md
+++ b/docs/development.md
@@ -1047,7 +1047,7 @@ clients/submitter/
     qt/                      Qt only, imported lazily (PySide6, falls back to PySide2)
     hosts/{maya,houdini,nuke,blender}/   adapter + launch glue per host
   tests/                     pytest; tests/integration/ is env-gated (see below)
-presets/sqi/                 the eleven reference preset YAML fixtures (six DCC render
+presets/sqi/                 the fourteen reference preset YAML fixtures (nine DCC render
                               presets, five ffmpeg transcode presets), validated by
                               internal/product/sqipresets_test.go against a per-preset
                               `want` map of expected category/params/extensions —
diff --git a/docs/preset-library.md b/docs/preset-library.md
index dfd6e9ed..8c3c2d17 100644
--- a/docs/preset-library.md
+++ b/docs/preset-library.md
@@ -164,7 +164,10 @@ copies show the **Update available** badge.
 The official library ships `Rendering`-category presets — `maya-layer-render`,
 `maya-scene-render`, `houdini-rop-render`, `nuke-write-render`,
 `nuke-script-render`, `blender-batch-render` — as ready targets for the
-[`sqi-submitter`](dcc-submitters.md) in-application submitters.
+[`sqi-submitter`](dcc-submitters.md) in-application submitters, plus
+`mistika-boutique-render`, `mistika-vr-render` and `mistika-workflows-render`,
+which have no in-application submitter and are submitted from the web UI or
+the API.
 Each declares its parameters using the [parameter convention
 contract](dcc-submitters.md#the-parameter-convention-contract) (`SceneFile`,
 `Frames`, `OutputDir`, plus per-host extras) so submitter pre-fill works out of
diff --git a/docs/products.md b/docs/products.md
index 1681c8f4..cda0cd91 100644
--- a/docs/products.md
+++ b/docs/products.md
@@ -131,18 +131,19 @@ configuration (see [worker-capabilities.md](worker-capabilities.md)). Runs
 `docker run --rm {{Param.Image}}`.
 
 **A note on the DCC reference presets and auto-detection.** The
-`presets/sqi/*.yaml` reference products (Maya, Nuke, Houdini, Blender — see
+`presets/sqi/*.yaml` reference products (Maya, Nuke, Houdini, Blender, Mistika
+Boutique/VR/Workflows — see
 [docs/dcc-submitters.md](dcc-submitters.md#reference-presets)) gate the same
 way: a `hostRequirements.attributes` entry requiring `attr.worker.tag.<app>`
 with `anyOf: ["true"]`. `sqi-worker` auto-detects a standard install of each
-of those four applications and advertises the matching tag (e.g. `maya`) with
+of those applications and advertises the matching tag (e.g. `maya`) with
 value `"true"` with no configuration — see [Capability
 auto-detection](worker-capabilities.md#capability-auto-detection-built-in-dcc-detectors)
 — which satisfies the `anyOf: ["true"]` match above directly, so a worker with
-a standard install matches these four built-in gates with zero per-worker
+a standard install matches these built-in gates with zero per-worker
 configuration. `docker` has no built-in detector, so the `container` product
 above still needs the manual `capability_tags: ["docker=true"]` entry.
-Nonstandard install paths for Maya/Nuke/Houdini/Blender, or an in-house tool
+Nonstandard install paths for Maya/Nuke/Houdini/Blender/Mistika, or an in-house tool
 not covered by a built-in detector, can add a manual tag or a [custom
 detector](worker-capabilities.md#writing-custom-detectors) instead.
 
diff --git a/docs/release-runbook.md b/docs/release-runbook.md
index 3506f1c6..9b92240c 100644
--- a/docs/release-runbook.md
+++ b/docs/release-runbook.md
@@ -247,9 +247,10 @@ VERSION=0.2.0
 
 ## Step 6b: Publish reference and testing presets to the preset library
 
-The presets authored in this repo — the eleven `presets/sqi/*.yaml` reference
-presets (Maya layer + scene, Nuke write + script, Houdini ROP, Blender batch;
-ffmpeg transcode, sequence-encode, and segment-transcode bash/PowerShell/EXPR)
+The presets authored in this repo — the fourteen `presets/sqi/*.yaml` reference
+presets (Maya layer + scene, Nuke write + script, Houdini ROP, Blender batch,
+Mistika Boutique + VR + Workflows; ffmpeg transcode, sequence-encode, and
+segment-transcode bash/PowerShell/EXPR)
 and the four `presets/testing/*.yaml` smoke-test presets (test-render and
 test-steps, each in bash + PowerShell) — are not distributed as part of the
 GitHub release or PyPI packages; they are published to the separate
@@ -294,7 +295,7 @@ go run ./cmd/presetgen -presets presets/testing -subdir testing -out /path/to/sq
 
 **Verify:**
 - The published index (`https://uberware.github.io/sqi-presets/index.json`)
-  lists all eleven presets under `sqi/` and the four test presets under `testing/`
+  lists all fourteen presets under `sqi/` and the four test presets under `testing/`
   with the correct `sha256`.
 - In the sqi web UI's Preset Library page, each preset installs successfully
   and its checksum verifies (no 422).
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 3be8a346..cdf54479 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -225,7 +225,7 @@ NATS can run embedded within `sqi-server` (simple mode) or as a separate cluster
 - S3-compatible storage support (thin layer: derived type, root validation, path staging via operator sync tool)
 - DCC submitter framework — in-application submitters for Maya, Houdini, Nuke, and Blender (the `sqi-submitter` Python package), built on the Python client
 - Compute location registry and step-level affinity (native OpenJD `attr.worker.computelocation`)
-- Chunk bounds (`SQI_CHUNK_BOUNDS` vendor extension) — expose each task chunk's frame start/end to the command line, used by the Maya and Blender reference presets
+- Chunk bounds (`SQI_CHUNK_BOUNDS` vendor extension) — expose each task chunk's frame start/end to the command line, used by the Maya, Blender and Mistika reference presets
 - Auto-retry and failure limits — per-task retry policy (max attempts, retry delay) and a job-level failure ceiling that auto-parks a job, resolved over four tiers (server → farm → queue → job) with per-task attempt history
 - Cross-job dependencies — a submission may declare `depends_on` upstream jobs (same farm, across queues); dependents are held `blocked` until every upstream completes, then released (or canceled if an upstream fails)
 - Testing job presets — ready-to-run `test-render`/`test-steps` presets (bash and PowerShell) published to the preset library for smoke-testing a farm
diff --git a/docs/worker-capabilities.md b/docs/worker-capabilities.md
index 594e6f06..5bdb38c3 100644
--- a/docs/worker-capabilities.md
+++ b/docs/worker-capabilities.md
@@ -112,11 +112,12 @@ GPU-capable on macOS or Windows.
 
 In addition to the hardware/OS tags above, `sqi-worker` runs a second,
 declarative detection engine (`internal/worker/capabilities`) that looks for
-installed creative applications — Maya, Nuke, Houdini, Blender — and
+installed creative applications — Maya, Nuke, Houdini, Blender, Mistika
+(Boutique/Ultima, VR, Workflows) and ffmpeg — and
 advertises a tag with value `"true"` automatically, with no per-worker
 configuration. This makes the software actually installed on a worker visible
 without hand-editing its config, and it's enough on its own to satisfy the
-`anyOf: ["true"]` gate the six shipped reference presets declare — a standard
+`anyOf: ["true"]` gate the shipped reference presets declare — a standard
 install matches those presets with zero configuration. Run
 `sqi-worker capabilities` any time to see what was found. See
 [`docs/dcc-submitters.md`](dcc-submitters.md#reference-presets) for how these
@@ -145,7 +146,7 @@ running worker is only picked up on the next restart.
 
 ### Built-in detectors
 
-Four built-ins ship embedded in the worker binary, one YAML file per
+Eight built-ins ship embedded in the worker binary, one YAML file per
 application under
 [`internal/worker/capabilities/builtins/`](https://github.com/uberware/sqi/tree/main/internal/worker/capabilities/builtins):
 
@@ -155,6 +156,20 @@ application under
 | `houdini` | `exe hython` (any OS, if on `PATH`); Linux `path_glob /opt/hfs*/bin/houdini`; macOS `path_glob /Applications/Houdini/Houdini*/Frameworks/Houdini.framework`; Windows `registry HKLM\SOFTWARE\Side Effects Software\Houdini` | `(?:hfs\|Houdini)(?P<v>[0-9]+\.[0-9]+)` against the matched path |
 | `nuke` | Linux `path_glob /usr/local/Nuke*/Nuke*`; macOS `path_glob /Applications/Nuke*/Nuke*.app`; Windows `registry HKLM\SOFTWARE\The Foundry\Nuke` | `Nuke([0-9]+\.[0-9]+)` against the matched path |
 | `blender` | `exe blender` (any OS, if on `PATH`); macOS `path_glob /Applications/Blender.app`; Windows `registry HKLM\SOFTWARE\BlenderFoundation\Blender` | none (presence only — no `-<version>` tags) |
+| `ffmpeg` | `exe ffmpeg` (any OS, if on `PATH`) — a PATH tool everywhere, so no install glob and no registry probe | none (presence only) |
+| `mistika` | Linux `path_glob /home/mistika/SGO Apps/Mistika Ultima*/bin/mistika`; macOS `path_glob /Applications/SGO Apps/Mistika Boutique.app*/Contents/MacOS/mistika`; Windows `path_glob C:\Program Files\SGO Apps\Mistika Boutique*\bin\mistika.exe` | `Mistika (?:Ultima\|Boutique) ?(?P<v>[0-9]+\.[0-9]+)` against the matched path |
+| `mistikavr` | Linux `path_glob /home/mistika/SGO Apps/Mistika VR*/bin/vr`; macOS `path_glob /Applications/SGO Apps/Mistika VR.app*/Contents/MacOS/vr`; Windows `path_glob C:\Program Files\SGO Apps\Mistika VR*\bin\vr.exe` | `Mistika VR ?(?P<v>[0-9]+\.[0-9]+)` against the matched path |
+| `mistikaworkflows` | Linux `path_glob /home/mistika/SGO Apps/Mistika Workflows*/bin/workflows`; macOS `path_glob /Applications/SGO Apps/Mistika Workflows.app*/Contents/MacOS/workflows`; Windows `path_glob C:\Program Files\SGO Apps\Mistika Workflows*\bin\workflows.exe` | `Mistika Workflows ?(?P<v>[0-9]+\.[0-9]+)` against the matched path |
+
+The three Mistika detectors are the only built-ins that probe Windows with a
+`path_glob` rather than a `registry` key — SGO installs under a versioned
+directory and registers no well-known key. They also deliberately carry **no
+`exe` check**: their binaries are `mistika`, `vr` and `workflows`, and a bare
+`PATH` probe for the last two would tag workers that have no Mistika at all.
+Detection is therefore by install location only, while the presets still
+invoke the bare command — so the binary must also be on the worker's `PATH`
+for the job to run. The install layouts are taken from the corresponding
+Smedge product definitions.
 
 A `path_glob`/`exe` check's matched signal is a filesystem path, so version
 extraction works there. A `registry` check's signal is the registry key
@@ -439,7 +454,7 @@ steps:
           anyOf: ["true"]
 ```
 
-This is the real syntax the six DCC reference products under `presets/sqi/`
+This is the real syntax the nine DCC reference products under `presets/sqi/`
 use — see [`docs/dcc-submitters.md`](dcc-submitters.md#reference-presets).
 (`presets/sqi/` also ships `Transcoding`-category ffmpeg presets that gate on
 `attr.worker.tag.ffmpeg` instead — see [`docs/preset-library.md`](preset-library.md#transcoding-reference-presets).)
diff --git a/internal/openjd/exprlimits.go b/internal/openjd/exprlimits.go
index bc216778..1d0db74d 100644
--- a/internal/openjd/exprlimits.go
+++ b/internal/openjd/exprlimits.go
@@ -191,13 +191,16 @@ type ExprLimits struct {
 // guard firing first, which is a derivation this file offered once and had to
 // withdraw (see [ExprLimits.SubmissionMemoryBytes]).
 //
-// The FLOORS all come from measurement, not from taste. The six reference
-// presets in presets/sqi/ -- the templates this repo itself ships -- were
-// measured per dimension by binary search: they cost at most 15 expression
-// positions, retain 0 let bytes, need at most 64 live bytes and at most 1
-// operation in any single evaluation. Every floor below leaves at least 4x
-// headroom over the worst of them (17x to 65536x in practice), so no operator
-// can tighten a knob to a value that rejects sqi's own templates.
+// The FLOORS all come from measurement, not from taste. The fourteen reference
+// presets in presets/sqi/ -- the templates this repo itself ships -- are
+// measured per dimension by binary search on every run, by
+// TestExprLimits_FloorsAcceptReferencePresets: at most 31 expression positions,
+// 1 retained byte, 390 live bytes and 15 operations in any single evaluation.
+// Every one of those maxima is set by ffmpeg-segment-transcode-expr, the only
+// preset doing real slice arithmetic; the render presets cost an order of
+// magnitude less. Every floor below leaves at least 4x headroom over the worst
+// of them (8x to 65536x in practice), so no operator can tighten a knob to a
+// value that rejects sqi's own templates.
 // TestExprLimits_FloorsAcceptReferencePresets re-measures that on every run
 // rather than trusting this paragraph.
 const (
diff --git a/internal/openjd/exprlimits_test.go b/internal/openjd/exprlimits_test.go
index 7d8820d3..b2457966 100644
--- a/internal/openjd/exprlimits_test.go
+++ b/internal/openjd/exprlimits_test.go
@@ -113,7 +113,7 @@ func TestExprLimits_OrDefaults(t *testing.T) {
 // asking the reader to trust a comment.
 //
 // A limit set absurdly low does not fail safe: it rejects legitimate templates
-// at submit. The cheapest available definition of "legitimate" is the eleven
+// at submit. The cheapest available definition of "legitimate" is the fourteen
 // reference presets this repo itself ships (presets/sqi/*.yaml, the same files
 // internal/product/sqipresets_test.go validates), so no floor may be tight
 // enough to reject one of them.
diff --git a/internal/presetgen/presetgen_test.go b/internal/presetgen/presetgen_test.go
index 7899b1e2..178b4d43 100644
--- a/internal/presetgen/presetgen_test.go
+++ b/internal/presetgen/presetgen_test.go
@@ -21,8 +21,8 @@ func TestBuild(t *testing.T) {
 	if err != nil {
 		t.Fatalf("Build: %v", err)
 	}
-	if len(got) != 11 {
-		t.Fatalf("got %d presets, want 11", len(got))
+	if len(got) != 14 {
+		t.Fatalf("got %d presets, want 14", len(got))
 	}
 	// Sorted by name.
 	want := []string{
@@ -30,7 +30,8 @@ func TestBuild(t *testing.T) {
 		"ffmpeg-segment-transcode-expr",
 		"ffmpeg-segment-transcode-powershell", "ffmpeg-sequence-encode",
 		"ffmpeg-transcode", "houdini-rop-render", "maya-layer-render",
-		"maya-scene-render", "nuke-script-render", "nuke-write-render",
+		"maya-scene-render", "mistika-boutique-render", "mistika-vr-render",
+		"mistika-workflows-render", "nuke-script-render", "nuke-write-render",
 	}
 	for i, w := range want {
 		if got[i].Entry.Name != w {
diff --git a/internal/product/sqipresets_test.go b/internal/product/sqipresets_test.go
index 14dddbfd..686622b8 100644
--- a/internal/product/sqipresets_test.go
+++ b/internal/product/sqipresets_test.go
@@ -74,6 +74,24 @@ func TestSQIReferencePresets(t *testing.T) {
 			params:     []string{"SceneFile", "Frames", "OutputPath"},
 			extensions: []string{"TASK_CHUNKING"},
 		},
+		// The three Mistika presets are the only shipped presets that declare
+		// SQI_CHUNK_BOUNDS: they invoke the renderer as `-s START -e END`, so
+		// they need a chunk's bounds rather than the chunk itself.
+		"mistika-boutique-render": {
+			category:   "Rendering",
+			params:     []string{"SceneFile", "Frames"},
+			extensions: []string{"TASK_CHUNKING", "SQI_CHUNK_BOUNDS"},
+		},
+		"mistika-vr-render": {
+			category:   "Rendering",
+			params:     []string{"SceneFile", "Frames"},
+			extensions: []string{"TASK_CHUNKING", "SQI_CHUNK_BOUNDS"},
+		},
+		"mistika-workflows-render": {
+			category:   "Rendering",
+			params:     []string{"SceneFile", "Frames"},
+			extensions: []string{"TASK_CHUNKING", "SQI_CHUNK_BOUNDS"},
+		},
 		"ffmpeg-transcode": {
 			category: "Transcoding",
 			params:   []string{"SourceFile", "OutputFile", "VideoCodec", "Quality", "AudioCodec"},
diff --git a/internal/worker/capabilities/builtins/mistika.yaml b/internal/worker/capabilities/builtins/mistika.yaml
new file mode 100644
index 00000000..ce96008b
--- /dev/null
+++ b/internal/worker/capabilities/builtins/mistika.yaml
@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#
+# Roots/bases/executables are the SGO install layout, taken from Smedge's own
+# Mistika_Ultima_And_Boutique.psx [FindLatestExecutable] block. Smedge searches
+# <Root>/<Base>*/<Exe> (ProcessJob.cpp _FindInRoot appends the trailing "*" when
+# the base carries no glob), so each glob below is that pattern spelled for
+# filepath.Glob. Ultima is the Linux product and Boutique the Windows/macOS one,
+# which is why the base differs by platform.
+#
+# The bundle directory is "Contents/MacOS", not the "Contents/MACOS" the .psx
+# writes: Smedge gets away with the latter only because macOS volumes are
+# case-insensitive by default, while filepath.Match is case-sensitive and would
+# never match a real bundle.
+tag: mistika
+checks:
+  - path_glob: "/home/mistika/SGO Apps/Mistika Ultima*/bin/mistika"                    # linux
+  - path_glob: "/Applications/SGO Apps/Mistika Boutique.app*/Contents/MacOS/mistika"   # macOS
+  - path_glob: 'C:\Program Files\SGO Apps\Mistika Boutique*\bin\mistika.exe'           # windows
+    os: windows
+version:
+  from: "Mistika (?:Ultima|Boutique) ?(?P<v>[0-9]+\\.[0-9]+)"
diff --git a/internal/worker/capabilities/builtins/mistikavr.yaml b/internal/worker/capabilities/builtins/mistikavr.yaml
new file mode 100644
index 00000000..f79f7af5
--- /dev/null
+++ b/internal/worker/capabilities/builtins/mistikavr.yaml
@@ -0,0 +1,17 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#
+# From Smedge's MistikaVR.psx [FindLatestExecutable] block; see mistika.yaml for
+# why the search is <Root>/<Base>*/<Exe> and why macOS reads "Contents/MacOS".
+#
+# There is deliberately no `exe: vr` check. The preset invokes the bare `vr`
+# command, but "vr" is generic enough that a PATH probe would tag workers with
+# no Mistika installed, and a falsely tagged worker is handed render work it
+# cannot do.
+tag: mistikavr
+checks:
+  - path_glob: "/home/mistika/SGO Apps/Mistika VR*/bin/vr"                    # linux
+  - path_glob: "/Applications/SGO Apps/Mistika VR.app*/Contents/MacOS/vr"     # macOS
+  - path_glob: 'C:\Program Files\SGO Apps\Mistika VR*\bin\vr.exe'             # windows
+    os: windows
+version:
+  from: "Mistika VR ?(?P<v>[0-9]+\\.[0-9]+)"
diff --git a/internal/worker/capabilities/builtins/mistikaworkflows.yaml b/internal/worker/capabilities/builtins/mistikaworkflows.yaml
new file mode 100644
index 00000000..5539f494
--- /dev/null
+++ b/internal/worker/capabilities/builtins/mistikaworkflows.yaml
@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#
+# From the FindExecutable* defaults in Smedge's MistikaWorkflows.json (the same
+# roots/bases/exe triple the .psx products spell in a [FindLatestExecutable]
+# section); see mistika.yaml for why the search is <Root>/<Base>*/<Exe>.
+#
+# As with mistikavr, there is deliberately no `exe: workflows` check: a bare
+# "workflows" on PATH is far too generic to treat as evidence of Mistika.
+tag: mistikaworkflows
+checks:
+  - path_glob: "/home/mistika/SGO Apps/Mistika Workflows*/bin/workflows"                     # linux
+  - path_glob: "/Applications/SGO Apps/Mistika Workflows.app*/Contents/MacOS/workflows"      # macOS
+  - path_glob: 'C:\Program Files\SGO Apps\Mistika Workflows*\bin\workflows.exe'              # windows
+    os: windows
+version:
+  from: "Mistika Workflows ?(?P<v>[0-9]+\\.[0-9]+)"
diff --git a/internal/worker/capabilities/mistika_builtins_test.go b/internal/worker/capabilities/mistika_builtins_test.go
new file mode 100644
index 00000000..12ac3fa6
--- /dev/null
+++ b/internal/worker/capabilities/mistika_builtins_test.go
@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+package capabilities
+
+import (
+	"path"
+	"strings"
+	"testing"
+)
+
+// The three Mistika detectors are translated from Smedge's own executable
+// discovery -- the [FindLatestExecutable] blocks in
+// Mistika_Ultima_And_Boutique.psx / MistikaVR.psx and the FindExecutable*
+// parameter defaults in MistikaWorkflows.json. Smedge searches
+// <Root>/<Base>*/<Exe>, appending the trailing "*" itself when the configured
+// base carries no glob character (ProcessJob.cpp _FindInRoot).
+//
+// This table restates the install layouts those sources describe, so the test
+// below checks the shipped globs against the vendor layout rather than against
+// a copy of themselves.
+var mistikaLayouts = []struct {
+	tag string
+	// installs are real paths the detector MUST match, one per platform.
+	installs []string
+	// version is the version this detector should extract from a versioned
+	// install directory, and versioned is the path carrying it.
+	versioned string
+	version   string
+}{
+	{
+		tag: "mistika",
+		installs: []string{
+			"/home/mistika/SGO Apps/Mistika Ultima 10.10/bin/mistika",
+			"/Applications/SGO Apps/Mistika Boutique.app/Contents/MacOS/mistika",
+			`C:\Program Files\SGO Apps\Mistika Boutique 10.10\bin\mistika.exe`,
+		},
+		versioned: `C:\Program Files\SGO Apps\Mistika Boutique 10.10\bin\mistika.exe`,
+		version:   "10.10",
+	},
+	{
+		tag: "mistikavr",
+		installs: []string{
+			"/home/mistika/SGO Apps/Mistika VR 10.10/bin/vr",
+			"/Applications/SGO Apps/Mistika VR.app/Contents/MacOS/vr",
+			`C:\Program Files\SGO Apps\Mistika VR 10.10\bin\vr.exe`,
+		},
+		versioned: "/home/mistika/SGO Apps/Mistika VR 10.10/bin/vr",
+		version:   "10.10",
+	},
+	{
+		tag: "mistikaworkflows",
+		installs: []string{
+			"/home/mistika/SGO Apps/Mistika Workflows 10.10/bin/workflows",
+			"/Applications/SGO Apps/Mistika Workflows.app/Contents/MacOS/workflows",
+			`C:\Program Files\SGO Apps\Mistika Workflows 10.10\bin\workflows.exe`,
+		},
+		versioned: "/Applications/SGO Apps/Mistika Workflows.app/Contents/MacOS/workflows",
+		version:   "",
+	},
+}
+
+// mistikaDetector returns the built-in detector emitting tag.
+func mistikaDetector(t *testing.T, tag string) Detector {
+	t.Helper()
+	ds, err := BuiltinDetectors()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, d := range ds {
+		if d.Tag == tag {
+			return d
+		}
+	}
+	t.Fatalf("no built-in detector emits the %q tag", tag)
+	return Detector{}
+}
+
+// TestMistikaDetectors_MatchVendorInstallLayout is the substantive check: each
+// shipped glob must actually match the SGO install path Smedge looks for.
+//
+// It matches with path.Match on slash-normalized strings rather than calling
+// filepath.Glob, for two reasons: the install paths are absolute and do not
+// exist on a test runner, and the Windows pattern's backslashes are separators
+// on Windows but escape characters to filepath.Match everywhere else, so a
+// host-native match would silently test something different per platform.
+// path.Match on normalized input is the same per-component wildcard semantics
+// filepath.Glob applies, checked identically on every runner.
+//
+// This is what catches the subtle failure: the .psx files spell the macOS
+// bundle directory "Contents/MACOS", which works for Smedge only because macOS
+// volumes are case-insensitive by default. filepath.Match is case-sensitive, so
+// copying that spelling would produce a detector that never fires on a real
+// install while looking perfectly correct.
+func TestMistikaDetectors_MatchVendorInstallLayout(t *testing.T) {
+	norm := func(s string) string { return strings.ReplaceAll(s, `\`, "/") }
+	for _, layout := range mistikaLayouts {
+		t.Run(layout.tag, func(t *testing.T) {
+			d := mistikaDetector(t, layout.tag)
+			for _, install := range layout.installs {
+				var matched bool
+				for _, c := range d.Checks {
+					ok, err := path.Match(norm(c.PathGlob), norm(install))
+					if err != nil {
+						t.Fatalf("bad pattern %q: %v", c.PathGlob, err)
+					}
+					if ok {
+						matched = true
+						break
+					}
+				}
+				if !matched {
+					t.Errorf("no check matches the vendor install path %s", install)
+				}
+			}
+		})
+	}
+}
+
+// TestMistikaDetectors_NoBareExeProbe pins the deliberate omission. Mistika's
+// binaries are `mistika`, `vr` and `workflows`; the presets invoke them by bare
+// name, so an `exe:` check is the obvious shortcut. It is wrong here: "vr" and
+// "workflows" are generic enough to exist on a machine with no Mistika, and a
+// falsely tagged worker gets handed render work it cannot run. Detection is by
+// install location only.
+func TestMistikaDetectors_NoBareExeProbe(t *testing.T) {
+	for _, layout := range mistikaLayouts {
+		t.Run(layout.tag, func(t *testing.T) {
+			d := mistikaDetector(t, layout.tag)
+			if len(d.Checks) == 0 {
+				t.Fatal("no checks")
+			}
+			for i, c := range d.Checks {
+				if c.Exe != "" {
+					t.Errorf("check %d probes PATH for %q; detection must be by install location", i, c.Exe)
+				}
+			}
+		})
+	}
+}
+
+// TestMistikaDetectors_WindowsCheckIsGated guards the one check whose pattern
+// is not portable: backslashes are separators on Windows and escapes to
+// filepath.Match elsewhere, so an ungated Windows glob would be an ErrBadPattern
+// (silently no matches) on POSIX rather than the no-op it looks like.
+func TestMistikaDetectors_WindowsCheckIsGated(t *testing.T) {
+	for _, layout := range mistikaLayouts {
+		t.Run(layout.tag, func(t *testing.T) {
+			d := mistikaDetector(t, layout.tag)
+			for i, c := range d.Checks {
+				if strings.Contains(c.PathGlob, `\`) && c.OS != "windows" {
+					t.Errorf("check %d has a backslash pattern %q but os = %q, want %q",
+						i, c.PathGlob, c.OS, "windows")
+				}
+			}
+		})
+	}
+}
+
+// TestMistikaDetectors_ExtractVersion checks the version regexes against a
+// versioned install directory, and confirms an unversioned one (the macOS
+// bundle, which carries no version in its name) yields no version tag rather
+// than a bogus one.
+func TestMistikaDetectors_ExtractVersion(t *testing.T) {
+	for _, layout := range mistikaLayouts {
+		t.Run(layout.tag, func(t *testing.T) {
+			d := mistikaDetector(t, layout.tag)
+			if got := d.extractVersion(layout.versioned); got != layout.version {
+				t.Errorf("extractVersion(%q) = %q, want %q", layout.versioned, got, layout.version)
+			}
+		})
+	}
+}
+
+// TestMistikaDetectors_EvaluateEmitsTags drives the real Evaluate path: a
+// worker whose glob hits must advertise the bare tag, and the versioned variant
+// when the install directory names a version.
+func TestMistikaDetectors_EvaluateEmitsTags(t *testing.T) {
+	d := mistikaDetector(t, "mistika")
+	hit := "/home/mistika/SGO Apps/Mistika Ultima 10.10/bin/mistika"
+	env := fakeEnv{
+		goos:  "linux",
+		globs: map[string][]string{"/home/mistika/SGO Apps/Mistika Ultima*/bin/mistika": {hit}},
+	}
+	got := strings.Join(d.Evaluate(env), ",")
+	if got != "mistika,mistika-10.10" {
+		t.Errorf("Evaluate = %q, want %q", got, "mistika,mistika-10.10")
+	}
+	if got := d.Evaluate(fakeEnv{goos: "linux"}); len(got) != 0 {
+		t.Errorf("a worker with no Mistika installed advertised %v", got)
+	}
+}
diff --git a/internal/worker/fmtres/exprlimits_test.go b/internal/worker/fmtres/exprlimits_test.go
index f6ee3a57..8e53f16d 100644
--- a/internal/worker/fmtres/exprlimits_test.go
+++ b/internal/worker/fmtres/exprlimits_test.go
@@ -574,10 +574,10 @@ func presetFiles(t *testing.T) []string {
 //
 // The baseline is needed rather than "expect zero errors" because these
 // presets are base-spec templates being pushed through the EXPR evaluator:
-// three of the six reference a chunked task parameter's .Start property
+// six of the fourteen reference a chunked task parameter's .Start property
 // ("{{Task.Param.Frame.Start}}", a TASK_CHUNKING spelling the EXPR evaluator
 // has no property for), which is an unrelated error and not this test's
-// business. It does mean those three stop resolving at the offending args
+// business. It does mean those six stop resolving at the offending args
 // entry, so their measured POSITION cost below is a lower bound on what the
 // whole step would charge -- which does not weaken the conclusion, because the
 // floor is sized from E4c's 1,841-position worked session rather than from
diff --git a/presets/sqi/mistika-boutique-render.yaml b/presets/sqi/mistika-boutique-render.yaml
new file mode 100644
index 00000000..48074c60
--- /dev/null
+++ b/presets/sqi/mistika-boutique-render.yaml
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+name: mistika-boutique-render
+title: Mistika Ultima & Boutique Render
+description: >-
+  Renders a saved Mistika .rnd job with the mistika binary, in frame chunks.
+  Requires workers tagged mistika=true with mistika on PATH. For a single movie
+  file, submit Frames "1". A starting point - duplicate to customize for your
+  pipeline.
+category: Rendering
+version: 1.0.0
+template:
+  specificationVersion: jobtemplate-2023-09
+  name: Mistika Ultima & Boutique Render
+  extensions: [TASK_CHUNKING, SQI_CHUNK_BOUNDS]
+  parameterDefinitions:
+    - name: SceneFile
+      type: PATH
+      objectType: FILE
+      dataFlow: IN
+      userInterface:
+        control: CHOOSE_INPUT_FILE
+        label: Scene File
+        fileFilters:
+          - label: Mistika render jobs
+            patterns: ["*.rnd"]
+        fileFilterDefault:
+          label: Mistika render jobs
+          patterns: ["*.rnd"]
+    - name: Frames
+      type: STRING
+      userInterface: { control: LINE_EDIT, label: Frame Range }
+  steps:
+    - name: Render
+      hostRequirements:
+        attributes:
+          - name: attr.worker.tag.mistika
+            anyOf: ["true"]
+      parameterSpace:
+        taskParameterDefinitions:
+          - name: Frame
+            type: CHUNK[INT]
+            range: "{{Param.Frames}}"
+            chunks:
+              defaultTaskCount: 10
+              rangeConstraint: CONTIGUOUS
+      script:
+        actions:
+          onRun:
+            command: mistika
+            args:
+              - "-r"
+              - "{{Param.SceneFile}}"
+              - "-s"
+              - "{{Task.Param.Frame.Start}}"
+              - "-e"
+              - "{{Task.Param.Frame.End}}"
diff --git a/presets/sqi/mistika-vr-render.yaml b/presets/sqi/mistika-vr-render.yaml
new file mode 100644
index 00000000..89718b34
--- /dev/null
+++ b/presets/sqi/mistika-vr-render.yaml
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+name: mistika-vr-render
+title: Mistika VR Render
+description: >-
+  Renders a saved Mistika VR .rnd job with the vr binary, in frame chunks.
+  Requires workers tagged mistikavr=true with vr on PATH. For a single movie
+  file, submit Frames "1". A starting point - duplicate to customize for your
+  pipeline.
+category: Rendering
+version: 1.0.0
+template:
+  specificationVersion: jobtemplate-2023-09
+  name: Mistika VR Render
+  extensions: [TASK_CHUNKING, SQI_CHUNK_BOUNDS]
+  parameterDefinitions:
+    - name: SceneFile
+      type: PATH
+      objectType: FILE
+      dataFlow: IN
+      userInterface:
+        control: CHOOSE_INPUT_FILE
+        label: Scene File
+        fileFilters:
+          - label: Mistika render jobs
+            patterns: ["*.rnd"]
+        fileFilterDefault:
+          label: Mistika render jobs
+          patterns: ["*.rnd"]
+    - name: Frames
+      type: STRING
+      userInterface: { control: LINE_EDIT, label: Frame Range }
+  steps:
+    - name: Render
+      hostRequirements:
+        attributes:
+          - name: attr.worker.tag.mistikavr
+            anyOf: ["true"]
+      parameterSpace:
+        taskParameterDefinitions:
+          - name: Frame
+            type: CHUNK[INT]
+            range: "{{Param.Frames}}"
+            chunks:
+              defaultTaskCount: 10
+              rangeConstraint: CONTIGUOUS
+      script:
+        actions:
+          onRun:
+            command: vr
+            args:
+              - "-r"
+              - "{{Param.SceneFile}}"
+              - "-s"
+              - "{{Task.Param.Frame.Start}}"
+              - "-e"
+              - "{{Task.Param.Frame.End}}"
diff --git a/presets/sqi/mistika-workflows-render.yaml b/presets/sqi/mistika-workflows-render.yaml
new file mode 100644
index 00000000..ec85c6b1
--- /dev/null
+++ b/presets/sqi/mistika-workflows-render.yaml
@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+name: mistika-workflows-render
+title: Mistika Workflows Render
+description: >-
+  Renders a saved Mistika Workflows .rnd job with the workflows binary, in frame
+  chunks. Requires workers tagged mistikaworkflows=true with workflows on PATH.
+  For a single movie file, submit Frames "1". A starting point - duplicate to
+  customize for your pipeline.
+category: Rendering
+version: 1.0.0
+template:
+  specificationVersion: jobtemplate-2023-09
+  name: Mistika Workflows Render
+  extensions: [TASK_CHUNKING, SQI_CHUNK_BOUNDS]
+  parameterDefinitions:
+    - name: SceneFile
+      type: PATH
+      objectType: FILE
+      dataFlow: IN
+      userInterface:
+        control: CHOOSE_INPUT_FILE
+        label: Scene File
+        fileFilters:
+          - label: Mistika render jobs
+            patterns: ["*.rnd"]
+        fileFilterDefault:
+          label: Mistika render jobs
+          patterns: ["*.rnd"]
+    - name: Frames
+      type: STRING
+      userInterface: { control: LINE_EDIT, label: Frame Range }
+  steps:
+    - name: Render
+      hostRequirements:
+        attributes:
+          - name: attr.worker.tag.mistikaworkflows
+            anyOf: ["true"]
+      parameterSpace:
+        taskParameterDefinitions:
+          - name: Frame
+            type: CHUNK[INT]
+            range: "{{Param.Frames}}"
+            chunks:
+              defaultTaskCount: 10
+              rangeConstraint: CONTIGUOUS
+      script:
+        actions:
+          onRun:
+            command: workflows
+            args:
+              - "-r"
+              - "{{Param.SceneFile}}"
+              - "-s"
+              - "{{Task.Param.Frame.Start}}"
+              - "-e"
+              - "{{Task.Param.Frame.End}}"