Feilkin · Feilkin · Feb 14, 2026 · Feb 14, 2026 · Feb 14, 2026 · Feb 15, 2026
diff --git a/.config/nextest.toml b/.config/nextest.toml
@@ -10,5 +10,5 @@ gpu-tests = { max-threads = 1 }
 [profile.default]
 # Assign GPU-intensive tests to the serial group
 [[profile.default.overrides]]
-filter = 'test(~generation) + test(~gemma) + test(~llm)'
+filter = 'test(~generation) + test(~gemma) + test(~llm) + test(~e2e)'
 test-group = 'gpu-tests'
diff --git a/.github/agents/implement-task.agent.md b/.github/agents/implement-task.agent.md
@@ -0,0 +1,104 @@
+---
+description: "Read a task file from tasks/, implement it, verify, commit, and mark done"
+argument-hint: "Task file name"
+tools: [execute, read, agent, edit, search, githits/search, todo]
+---
+
+You are an implementation agent for the Onyxia project. Your job is to read a single task file, implement all required changes, verify correctness, commit the result, and mark the task as done.
+
+## Input
+
+The user provides a task file name.
+
+## Workflow
+
+Follow these steps **in order**. Do not skip steps. Do not proceed to the next step until the current step is fully complete.
+
+### Step 1: Read and understand the task
+
+1. Read the task file at `tasks/<number>-*.md` in full.
+2. If the task references a plan file, read the relevant sections of the plan to get additional context.
+3. Read `ARCHITECTURE.md` and `.github/copilot-instructions.md` to understand project conventions.
+4. Identify the task's dependencies (listed at the top of the task file). Verify that each dependency task has been completed — its file should be prefixed with `_done_` (e.g., `tasks/_done_018-onyxia-core-crate.md`). If any dependency is not done, **stop and report which dependencies are missing**. Do not attempt the task.
+5. Summarize your understanding of the task and create a todo list with specific implementation steps.
+
+### Step 2: Implement the changes
+
+1. Work through each todo item, marking items in-progress and completed as you go.
+2. Follow the project's code conventions:
+   - Rust 2024 edition idioms
+   - `///` doc comments on all public APIs
+   - `Result<T, E>` with `?` operator for error handling
+   - Unit tests in `#[cfg(test)]` modules
+3. **Dependency management**: Use `cargo add <crate>` to add dependencies — never edit `Cargo.toml` by hand. Before adding any new external dependency (not a workspace crate), list it and ask for confirmation.
+4. Write idiomatic Rust: iterators, pattern matching, proper ownership.
+5. Implement everything specified in the task's "Scope" section. Do not implement more or less than what the task specifies.
+
+### Step 3: Verify the changes
+
+Run **all** of these checks. Every single one must pass before proceeding to Step 4.
+
+```bash
+cargo fmt --all                                    # Format code
+cargo clippy --workspace                           # Lint — no warnings allowed
+cargo build --workspace                            # Full workspace build
+cargo nextest run                                  # Run all non-ignored tests
+cargo nextest run --run-ignored=all                # Run GPU tests
+```
+
+If any check fails:
+1. Read the error output carefully.
+2. Fix the issue.
+3. Re-run **all** checks from the beginning (not just the one that failed).
+
+Do not proceed to Step 4 until all four commands succeed.
+
+### Step 4: Verify the Definition of Done
+
+Re-read the "Definition of Done" section of the task file. Go through each checkbox item and verify that it has been satisfied by your implementation. If any item is not satisfied, go back to Step 2 and implement the missing piece, then re-run Step 3.
+
+### Step 5: Commit the changes
+
+Create a single commit using [Conventional Commits](https://www.conventionalcommits.org/) style:
+
+```bash
+git add -A
+git commit -m "<type>(<scope>): <description>
+
+<body>"
+```
+
+**Commit message rules:**
+- `<type>`: Use `feat` for new features/crates, `refactor` for restructuring, `test` for test-only changes, `fix` for bug fixes, `chore` for non-code changes.
+- `<scope>`: The primary crate affected (e.g., `core`, `compiler`, `operators`, `runtime`, `cli`). Use multiple scopes separated by `/` if needed (e.g., `core/compiler`).
+- `<description>`: Imperative mood, lowercase, no period. Summarize what was done.
+- `<body>`: Brief list of what was implemented (bullet points). Reference the task number.
+
+Example:
+```
+feat(core): add onyxia-core crate with IR, traits, and plan types
+
+- Graph IR with StableGraph, IrNode, TensorDef
+- Operator and Pass traits with InferenceCtx, FoldCtx, PlanCtx
+- TensorShape enum (Static, Symbolic, Absent — no Unknown)
+- SymbolicExpr parser/evaluator moved from onyxia-compiler
+- CompiledModel and PlannedOp plan types
+- OperatorRegistry
+```
+
+### Step 6: Mark the task as done
+
+Rename the task file by prepending `_done_` to the filename:
+
+```bash
+mv tasks/<number>-<name>.md tasks/_done_<number>-<name>.md
+```
+
+## Important Rules
+
+- **Do not modify files outside the task's scope** unless the task explicitly requires it (e.g., updating workspace `Cargo.toml`).
+- **Do not add dependencies without listing them first.** Workspace-internal crate dependencies (e.g., `onyxia-core = { path = "../onyxia-core" }`) are fine to add without asking.
+- **Stop immediately if dependency tasks are not done.** Do not attempt partial implementation.
+- **Run the full verification suite (Step 3) before committing.** No exceptions.
+- **One commit per task.** Do not create multiple commits.
+- **Do not generate "implementation report" or other useless markdown files.**
diff --git a/.github/agents/task-master.agent.md b/.github/agents/task-master.agent.md
@@ -0,0 +1,9 @@
+---
+name: task-master
+description: Orchestrates sub-agents to complete tasks from tasks/-folder.
+argument-hint: Which tasks to implement (018-025)
+tools: [read/readFile, agent, edit/createFile, edit/editFiles, search/fileSearch, search/listDirectory, todo]
+agents: ["implement-task"]
+---
+Resolve task numbers to task file names (`tasks/xxx-something.md`).
+For each task file in the given range, invoke "implement-task" sub-agent with "Implement task: {task file name}, and report back with a summary of what was implemented, or any blockers that are preveting you from completing the task". Do not add anything else to the invocation. If the sub-agent becomes blocked by some issue, create a new task to solve that issue, and invoke another sub-agent to implement that task, then try running the blocked agent again.
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
@@ -1,28 +1,30 @@
 # Copilot Instructions for Onyxia
 
-Onyxia is a **GPU compute shader runtime for ONNX models**, built in Rust 2024 edition. It compiles ONNX operator graphs into WGSL compute shaders executed via `wgpu`.
+Onyxia is a **GPU compute shader runtime for ONNX models**, built in Rust 2024 edition. It uses a dispatch-based execution model where operators compile their shaders at compile time and compute shapes at runtime from actual input tensors.
 
 ### Architecture
 
 ```
-┌─────────────────┐     ┌──────────────────┐      ┌─────────────────┐
-│  onyxia-onnx    │────▶│ onyxia-planner  │────▶│ onyxia-runtime  │
-│  (ONNX parser)  │     │ (execution graph)│      │ (GPU executor)  │
-└─────────────────┘     └──────────────────┘      └─────────────────┘
-                                                        ▲
-                                                        │
-                                               ┌─────────────────┐
-                                               │   onyxia-cli    │
-                                               │ (CLI interface) │
-                                               └─────────────────┘
+┌─────────────────┐     ┌──────────────────┐      ┌──────────────────┐
+│  onyxia-onnx    │────▶│ onyxia-compiler  │────▶│ onyxia-runtime   │
+│  (ONNX parser)  │     │ (dispatch model) │      │ (GPU executor)   │
+└─────────────────┘     └──────────────────┘      └──────────────────┘
+                                ▲                           ▲
+                                │                           │
+                    ┌───────────┴───────────┐      ┌───────┴──────────┐
+                    │  onyxia-operators     │      │   onyxia-cli     │
+                    │  (3 core operators)   │      │  (CLI interface) │
+                    └───────────────────────┘      └──────────────────┘
 ```
 
 | Crate | Purpose |
 |-------|---------|
 | `onyxia-onnx` | Parse ONNX protobuf models into internal IR |
-| `onyxia-planner` | Generate execution plans with pre-compiled WGSL shaders |
-| `onyxia-runtime` | Execute execution plans on GPU via `wgpu` |
-| `onyxia-cli` | CLI for testing models, generating dot graphs, benchmarking |
+| `onyxia-core` | IR graph, operator/dispatch traits, compiled model types, operator registry |
+| `onyxia-operators` | 3 core operators (Add, Mul, Reshape) with WGSL shaders |
+| `onyxia-compiler` | Build dispatch models with pre-compiled WGSL shaders |
+| `onyxia-runtime` | Execute dispatch models on GPU via `wgpu` with register-based routing |
+| `onyxia-cli` | CLI for model inspection, DOT graphs, validation |
 
 Read [ARCHITECTURE.md](../ARCHITECTURE.md) for more details.
 
@@ -81,6 +83,36 @@ pub mod onnx {
 - For GPU code, write WGSL in separate `.wgsl` files and use `naga_oil` for runtime compilation
 
 ### Cross-Crate Communication
-- `onyxia-onnx` exports an IR that `onyxia-planner` consumes
-- `onyxia-planner` produces execution plans for `onyxia-runtime`
+- `onyxia-onnx` exports a `Graph` that `onyxia-compiler` consumes
+- `onyxia-core` defines the `Operator` trait (with `create_dispatch()`) and `OpDispatch` trait
+- `onyxia-operators` implements operators and exports `core_operator_registry()`
+- `onyxia-compiler` produces `CompiledModel` (dispatch entries + register routing) for `onyxia-runtime`
+- `onyxia-runtime` executes dispatch entries using a register-based execution model
 - Keep crate boundaries clean; avoid circular dependencies
+
+### Key Concepts
+
+**Dispatch-based execution:**
+- Each operator implements `Operator::create_dispatch()` to produce an `OpDispatch` object
+- At runtime, `OpDispatch::dispatch(inputs, ctx) -> outputs` computes shapes from actual inputs and executes GPU work
+- No compile-time shape inference or constant folding — shapes determined at runtime
+
+**Register machine:**
+- Runtime maintains a vector of `Option<RuntimeTensor>` (the register file)
+- Each tensor in the IR graph maps to a register index
+- Operations read inputs from registers and write outputs to registers
+
+**Operator trait:**
+```rust
+pub trait Operator: Send + Sync {
+    fn name(&self) -> &str;
+    fn create_dispatch(&self, ctx: &mut CompileCtx) -> Result<Box<dyn OpDispatch>>;
+}
+```
+
+**OpDispatch trait:**
+```rust
+pub trait OpDispatch: Send + Sync {
+    fn dispatch(&self, inputs: Vec<RuntimeTensor>, ctx: &mut DispatchCtx) -> Result<Vec<RuntimeTensor>>;
+}
+```