TUI build korjattu

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -34,3 +34,9 @@ Cargo.lock
 *.pdb
 
 # End of https://www.toptal.com/developers/gitignore/api/rust,linux
+
+# Ajonaikaiset tietokannat
+*.db
+
+# Wanha versio
+temp/

network-poc/AGENTBUILDER.md

@@ -0,0 +1,215 @@
+# Kipinä Agent Builder — Suunnitelma
+
+Käyttäjä voi rakentaa omia agentteja "hahmolomakkeella": valitsee avatarin, roolin, kielimallin ja muokkaa prompteja. Agentit tallentuvat localStorageen ja ovat käytettävissä pipelineissa.
+
+## Nykytila
+
+```js
+// Kovakoodattu agentPrompts-objekti
+const agentPrompts = {
+    manager: { name: 'Manageri', model: 'qwen2.5-coder:7b', default: '...' },
+    coder:   { name: 'Koodari', model: 'qwen2.5-coder:7b', default: '...' },
+    tofuist: { name: 'Tofuist', model: 'qwen2.5-coder:7b', docs: '/docs/tofu-cheatsheet.md', default: '...' },
+    // ...
+};
+```
+
+**Ongelma:** Uuden agentin lisääminen vaatii koodimuutoksen index.html:ään.
+
+## Tavoite
+
+```
+┌─────────────────────────────────────────────────────┐
+│  Agent Builder -lomake                              │
+│                                                     │
+│  ┌─────────┐  Nimi: [Tofuist          ]             │
+│  │ 🦎      │  Rooli: [IaC / Infra    ▼]            │
+│  │ avatar  │  Malli: [qwen2.5-coder:7b ▼]          │
+│  └─────────┘  Docs:  [/docs/tofu-cheatsheet.md]    │
+│                                                     │
+│  System Prompt:                                     │
+│  ┌─────────────────────────────────────────────┐    │
+│  │ You are an OpenTofu/Terraform IaC specialist│    │
+│  │ ...                                         │    │
+│  └─────────────────────────────────────────────┘    │
+│                                                     │
+│  LLM-parametrit:                                    │
+│  Temperature: [0.7]  Top-k: [40]  Max tokens: [512]│
+│                                                     │
+│  [💾 Tallenna]  [🗑️ Poista]  [📤 Export JSON]       │
+└─────────────────────────────────────────────────────┘
+```
+
+## Building Blocks
+
+### 1. Agenttiskeema
+
+```js
+{
+    id: 'tofuist',                          // uniikki tunniste
+    name: 'Tofuist',                        // näyttönimi
+    avatar: '/avatars/gecko_notext.png',     // avatar-kuvan polku
+    role: 'iac',                             // rooli-template
+    model: 'qwen2.5-coder:7b',             // eksakti Ollama-mallinimi
+    color: '#e3a336',                        // teemaväri UI:ssa
+    docs: '/docs/tofu-cheatsheet.md',        // valinnainen referenssidokumentti
+    prompt: 'You are an OpenTofu...',        // system prompt
+    params: {                                // LLM-parametrit
+        temperature: 0.7,
+        top_k: 40,
+        max_tokens: 512,
+        repetition_penalty: 1.15
+    }
+}
+```
+
+### 2. Rooli-templatet (alasvetovalikko)
+
+Valmiit pohjat jotka tuovat oletuspromptit ja parametrit:
+
+| Rooli | Oletusprompt | Parametrit |
+|-------|-------------|------------|
+| Koodari | "Kirjoita selkeää, testattavaa koodia" | temp 0.7, max 512 |
+| QA / Testaus | "Kirjoita testejä, etsi virheitä" | temp 0.4, max 512 |
+| DevOps | "Dockerfile, Compose, CI/CD" | temp 0.5, max 512 |
+| DevSecOps | "Tietoturva-auditointi, OWASP" | temp 0.3, max 512 |
+| Arkkitehti | "Järjestelmäsuunnittelu, rajapinnat" | temp 0.6, max 512 |
+| IaC / Infra | "OpenTofu/Terraform HCL-koodi" | temp 0.5, max 512 |
+| Data | "Tietokannat, SQL, datamallit" | temp 0.5, max 512 |
+| Manageri | "Tehtävien jako ja koordinointi" | temp 0.8, max 200 |
+| Kirjoittaja | "Dokumentaatio, README, ohjeet" | temp 0.8, max 512 |
+| Vapaa | (tyhjä, käyttäjä kirjoittaa) | temp 0.7, max 512 |
+
+### 3. Malli-valitsin
+
+Lista saatavilla olevista malleista — haetaan dynaamisesti:
+
+```
+Hub-kysely: GET /api/models → palauttaa yhdistettyjen solmujen mallit
+
+Tai staattinen lista:
+- qwen2.5-coder:7b    (oletus, natiivi GPU)
+- qwen2.5-coder:1.5b  (kevyt)
+- qwen2.5-coder:0.5b  (selain Wasm)
+- deepseek-r1          (reasoning)
+- llama3.2:3b          (yleiskäyttö)
+```
+
+Pitkän aikavälin tavoite: hub ilmoittaa WebSocketin kautta mitkä mallit ovat saatavilla.
+
+### 4. Avatar-valitsin
+
+Valmiit avatarit + mahdollisuus ladata oma:
+
+| Hahmo | Tiedosto | Eläin |
+|-------|----------|-------|
+| Asiakas | kettu_notext.png | Kettu |
+| Manageri | karhunpentu.png | Karhunpentu |
+| Koodari | kipina_notext.png | Salamanteri |
+| Data | pesukarhu_notext.png | Pesukarhu |
+| QA | susi_notext.png | Pikkususi |
+| DevOps | laiskiainen_notext.png | Laiskiainen |
+| Tarkkailija | aikuinen_susi.png | Aikuinen susi |
+| Tofuist | gecko_notext.png | Gecko/Lisko |
+| Arkkitehti | ??? | (tulossa) |
+| DevSecOps | ??? | (tulossa) |
+
+### 5. Docs-kenttä (referenssidokumentti)
+
+Agentti voi viitata ulkoiseen dokumenttiin joka ladataan promptiin:
+
+```
+docs: '/docs/tofu-cheatsheet.md'  →  haetaan fetch():llä, cachetetaan _docsCache-kenttään
+```
+
+**Toiminta:**
+1. Ensimmäisellä `kpnRun`-kutsulla ladataan docs-URL
+2. Sisältö cachetetaan `agent._docsCache`-kenttään
+3. Liitetään promptiin: `"Reference:\n" + docsContent`
+4. Ei ladata uudelleen saman session aikana
+
+**Rajoitukset:**
+- Max ~3000 tokenia (~10 KB) — pidempi docs tiivistetään
+- Vain tekstitiedostot (.md, .txt)
+
+### 6. Tallennus (localStorage)
+
+```js
+// Tallennusavain
+'kpn-custom-agents' → JSON.stringify([ agentSkeema1, agentSkeema2, ... ])
+
+// Ladattaessa
+const customAgents = JSON.parse(localStorage.getItem('kpn-custom-agents') || '[]');
+const defaultAgents = { manager: {...}, coder: {...}, ... };
+const agentPrompts = { ...defaultAgents };
+for (const agent of customAgents) {
+    agentPrompts[agent.id] = agent;
+}
+```
+
+**Oletusagentit** (manager, coder, tester, qa, data) ovat aina mukana — niitä ei voi poistaa, mutta prompteja voi muokata.
+
+**Käyttäjäagentit** (tofuist, arkkitehti, devsecops, ...) tallentuvat localStorageen ja latautuvat käynnistyksessä.
+
+### 7. Export / Import
+
+```js
+// Export — JSON-tiedosto
+const blob = new Blob([JSON.stringify(agent, null, 2)], { type: 'application/json' });
+// → agent-tofuist.json
+
+// Import — tiedoston valinta tai drag & drop
+// Validoidaan skeema, lisätään agentPrompts-objektiin
+```
+
+Mahdollistaa agenttien jakamisen tiimin kesken.
+
+## Toteutusvaiheet
+
+### Vaihe 1: Hahmolomake UI
+- Avatar-grid valitsin
+- Rooli-template alasvetovalikko (täyttää oletuspromptit)
+- Malli-valitsin
+- System prompt -tekstikenttä
+- LLM-parametrit (temperature, top-k, max_tokens)
+- Tallenna/Poista-napit
+
+### Vaihe 2: Dynaaminen agenttirekisteri
+- `agentPrompts` ladataan localStoragesta
+- Oletusagentit + käyttäjän agentit yhdistetään
+- Avatar-kortit renderöidään dynaamisesti (ei HTML:ssä)
+- Värimapit generoidaan agenttiskeemasta
+
+### Vaihe 3: Pipeline käyttää dynaamisia agentteja
+- Pipeline-vaiheet viittaavat agentin id:hen (ei kovakoodattuun nimeen)
+- Käyttäjä voi valita mitkä agentit osallistuvat pipelineen
+- Tofuist voi korvata DevOpsin IaC-projekteissa
+
+### Vaihe 4: Mallirekisteri (hub-integraatio)
+- Hub tarjoaa `/api/models`-endpointin
+- Saatavilla olevat mallit näkyvät valitsimessa reaaliajassa
+- Solmun liittyessä/poistuessa mallit päivittyvät
+
+## Arkkitehtuurikaavio
+
+```
+┌──────────────────────────────────────────────────┐
+│  Agent Builder UI                                │
+│  ┌──────────┐ ┌──────────┐ ┌──────────────────┐  │
+│  │ Avatar   │ │ Rooli    │ │ Malli-valitsin   │  │
+│  │ Grid     │ │ Template │ │ (hub/staattinen) │  │
+│  └────┬─────┘ └────┬─────┘ └────────┬─────────┘  │
+│       └─────────────┼───────────────┘             │
+│                     ▼                             │
+│  ┌──────────────────────────────────────────────┐ │
+│  │  Agent Schema  { id, name, avatar, model,   │ │
+│  │                  role, color, docs, prompt,  │ │
+│  │                  params }                    │ │
+│  └──────────────────┬───────────────────────────┘ │
+│                     │                             │
+│       ┌─────────────┼─────────────┐               │
+│       ▼             ▼             ▼               │
+│  localStorage   Org Chart    Pipeline             │
+│  (persist)      (render)     (execute)            │
+└──────────────────────────────────────────────────┘
+```

network-poc/Dockerfile.native

@@ -0,0 +1,21 @@
+# Native-node: Rust + Ollama-client (ei GPU-tunnistusta)
+FROM rust:slim AS builder
+RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY Cargo.toml Cargo.lock* ./
+COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY native-node/src native-node/src
+# Dummy-cratet workspace-yhteensopivuuteen
+COPY hub/Cargo.toml hub/Cargo.toml
+COPY node/Cargo.toml node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
+RUN mkdir -p hub/src node/src cli/src && touch hub/src/main.rs node/src/lib.rs cli/src/main.rs
+RUN --mount=type=cache,target=/usr/local/cargo/registry \
+    --mount=type=cache,target=/app/target \
+    cargo build --release -p native-node --no-default-features \
+    && cp /app/target/release/native-node /usr/local/bin/native-node
+
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
+COPY --from=builder /usr/local/bin/native-node /usr/local/bin/native-node
+CMD ["native-node"]

network-poc/Dockerfile.native-node

@@ -1,30 +1,36 @@
 FROM rust:slim AS builder
 
 RUN apt-get update && apt-get install -y \
-    pkg-config libssl-dev g++ \
+    pkg-config libssl-dev g++ libvulkan-dev \
     && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
-COPY Cargo.toml Cargo.lock ./
+COPY Cargo.toml ./
+COPY Cargo.loc[k] ./
 COPY hub/Cargo.toml hub/Cargo.toml
 COPY node/Cargo.toml node/Cargo.toml
 COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
 
 # Tyhjät src-tiedostot riippuvuuksien esikääntämistä varten
-RUN mkdir -p hub/src node/src native-node/src \
+RUN mkdir -p hub/src node/src native-node/src cli/src \
     && echo "fn main(){}" > hub/src/main.rs \
     && echo "" > node/src/lib.rs \
     && echo "fn main(){}" > native-node/src/main.rs \
+    && echo "fn main(){}" > cli/src/main.rs \
     && cargo build --release -p native-node 2>/dev/null || true
 
 COPY native-node/src native-node/src
-RUN cargo build --release -p native-node
+# Touch pakottaa rekompilauksen dummy-binaryn yli
+RUN touch native-node/src/main.rs && cargo build --release -p native-node
 
 FROM debian:bookworm-slim
-RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y ca-certificates libvulkan1 && rm -rf /var/lib/apt/lists/*
 COPY --from=builder /app/target/release/native-node /usr/local/bin/native-node
 
-ENV HUB_URL=ws://hub:3000/ws
+ENV HUB_URL=ws://agentic-poc:3000/ws
+ENV OLLAMA_URL=http://ollama:11434
+ENV OLLAMA_MODEL=qwen2.5-coder:7b
 ENV ALLOCATED_GB=4
 
 CMD ["native-node"]

network-poc/Dockerfile.prod

@@ -1,47 +1,63 @@
 # syntax=docker/dockerfile:1
-FROM rust:slim AS builder
 
-RUN apt-get update && apt-get install -y \
+# --- Vaihe 1: Frontend (Astro) ---
-    curl pkg-config libssl-dev g++ \
+FROM node:22-slim AS frontend
-    && rm -rf /var/lib/apt/lists/*
+WORKDIR /app/frontend
+# Riippuvuudet ensin → cache-kerros (muuttuu harvoin)
+COPY frontend/package.json frontend/package-lock.json* ./
+RUN npm install --silent
+# Lähdekoodi → muuttuu usein, mutta npm install on cachessa
+COPY frontend/ .
+RUN npm run build
 
+# --- Vaihe 2: Wasm (wasm-pack) ---
+FROM rust:slim AS wasm-builder
+RUN apt-get update && apt-get install -y curl pkg-config libssl-dev g++ && rm -rf /var/lib/apt/lists/*
 RUN curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
-
 WORKDIR /app
-
+COPY Cargo.toml Cargo.lock* ./
-# Kopioi kaikki Cargo-tiedostot
+COPY node/Cargo.toml node/Cargo.toml
-COPY Cargo.toml ./
+COPY node/src node/src
-COPY Cargo.lock* ./
+# Dummy-cratet jotta workspace Cargo.toml on tyytyväinen
 COPY hub/Cargo.toml hub/Cargo.toml
+COPY native-node/Cargo.toml native-node/Cargo.toml
+COPY cli/Cargo.toml cli/Cargo.toml
+RUN mkdir -p hub/src native-node/src cli/src && touch hub/src/main.rs native-node/src/main.rs cli/src/main.rs
+RUN --mount=type=cache,target=/usr/local/cargo/registry \
+    --mount=type=cache,target=/app/target \
+    cd node && wasm-pack build --target web --out-dir /app/wasm-pkg
+
+# --- Vaihe 3: Hub (Rust) ---
+FROM rust:slim AS hub-builder
+RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*
+WORKDIR /app
+COPY Cargo.toml Cargo.lock* ./
+COPY hub/Cargo.toml hub/Cargo.toml
+COPY hub/src hub/src
+# Tarvitaan dummy-cratet jotta workspace kompiloi
 COPY node/Cargo.toml node/Cargo.toml
 COPY native-node/Cargo.toml native-node/Cargo.toml
 COPY cli/Cargo.toml cli/Cargo.toml
-
+RUN mkdir -p node/src native-node/src cli/src && touch node/src/lib.rs native-node/src/main.rs cli/src/main.rs
-# Kopioi lähdekoodi
-COPY hub/src hub/src
-COPY node/src node/src
-COPY native-node/src native-node/src
-COPY cli/src cli/src
-COPY static static
-
-# Rakenna Wasm — cache mount pitää Cargo-rekisterin ja target-kansion buildien välillä
-RUN --mount=type=cache,target=/usr/local/cargo/registry \
-    --mount=type=cache,target=/app/target \
-    cd node && wasm-pack build --target web --out-dir ../static/pkg
-
-# Rakenna Hub
 RUN --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=/app/target \
     cargo build --release -p hub \
     && cp /app/target/release/hub /usr/local/bin/hub
 
+# --- Vaihe 4: Tuotantoimage ---
 FROM debian:bookworm-slim
 RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
 
-COPY --from=builder /usr/local/bin/hub /usr/local/bin/hub
+COPY --from=hub-builder /usr/local/bin/hub /usr/local/bin/hub
-COPY --from=builder /app/static /app/static
+COPY --from=frontend /app/frontend/dist /app/frontend/dist
+COPY --from=wasm-builder /app/wasm-pkg /app/frontend/dist/pkg
+
+# Kopioidaan GUIDE.md ja templates
+COPY frontend/public/GUIDE.md /app/frontend/dist/GUIDE.md
+COPY frontend/public/templates /app/frontend/dist/templates
+COPY frontend/public/avatars /app/frontend/dist/avatars
 
 WORKDIR /app
-ENV STATIC_DIR=/app/static
+ENV STATIC_DIR=/app/frontend/dist
 EXPOSE 3000
 CMD ["hub"]

network-poc/TODO.md

@@ -0,0 +1,26 @@
+# TODO — Kipinä Agentic Network
+
+## Turvallisuus
+- [ ] **Tulosten validointi** — solmu voi palauttaa haitallista koodia. Tarvitaan proof-of-work tai challenge-response -mekanismi
+- [ ] **Reputaatiojärjestelmä** — solmujen luotettavuuden seuranta: onnistuneet tehtävät, vasteaika, laatu
+- [ ] **Koodin sandboxaus** — generoitu koodi pitää ajaa eristetyssä ympäristössä ennen käyttäjälle näyttämistä
+- [ ] **Solmun identiteetti** — rekisteröityminen ja tunnistautuminen (API-avain / token)
+
+## Yksityisyys
+- [ ] **Promptien salaus** — käyttäjän promptit menevät tuntemattomalle solmulle selkotekstinä
+- [ ] **End-to-end enkryptio** — hub ei näe promptin sisältöä, vain reitittää
+- [ ] **Tietosuojaseloste** — käyttäjille kerrottava miten data kulkee ja kuka sen näkee
+- [ ] **Opt-in malli** — käyttäjä valitsee haluaako käyttää yhteisösolmuja vai vain omaa
+
+## Väärinkäytön esto
+- [ ] **Rate limiting per käyttäjä** — nykyinen IP-pohjainen ei riitä, tarvitaan autentikointi
+- [ ] **Solmun kuormitusraja** — solmu voi asettaa max tehtävät/minuutti
+- [ ] **Token-talous** — laskentaresurssien käyttö vaatii Kipinä-tokeneita (gamification jo aloitettu)
+- [ ] **Abuse reporting** — mekanismi haitallisten solmujen ilmiantamiseen
+
+## Seuraavat ominaisuudet
+- [ ] Agenttien välinen keskustelu (manageri ohjaa dynaamisesti)
+- [ ] Tehtävähistoria ja tulosten tallennus
+- [ ] Prometheus/OpenTelemetry -metriikat
+- [ ] Solmujen terveystarkistukset (ping/pong)
+- [ ] Streaming-vastaukset Ollaman kautta

network-poc/build-binaries.sh

@@ -0,0 +1,63 @@
+#!/bin/bash
+# Käännä kipina-node binäärit kaikille alustoille
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+OUT="$SCRIPT_DIR/frontend/public/download"
+HASH_FILE="$OUT/.build-hash"
+mkdir -p "$OUT"
+
+# Tarkistetaan onko native-node muuttunut edellisen buildin jälkeen
+CURRENT_HASH=$(git -C "$SCRIPT_DIR" log -1 --format=%H -- native-node/ Cargo.toml Cargo.lock)
+if [ -n "$(git -C "$SCRIPT_DIR" status --porcelain -- native-node/ Cargo.toml Cargo.lock)" ]; then
+    CURRENT_HASH="dirty-$(git -C "$SCRIPT_DIR" status --porcelain | md5sum | awk '{print $1}')"
+fi
+
+if [ -f "$HASH_FILE" ] && [ "$(cat "$HASH_FILE")" = "$CURRENT_HASH" ]; then
+    echo "=== Kipinä Node — ei muutoksia, ohitetaan build ==="
+    ls -lh "$OUT"/kipina-node-* 2>/dev/null || true
+    exit 0
+fi
+
+echo "=== Kipinä Node — Binary Build ==="
+
+# macOS ARM (natiivi)
+echo "[1/4] macOS ARM64..."
+cd "$SCRIPT_DIR"
+cargo build --release -p native-node --no-default-features 2>&1 | tail -1
+cp target/release/native-node "$OUT/kipina-node-macos-arm64"
+echo "      $(ls -lh "$OUT/kipina-node-macos-arm64" | awk '{print $5}')"
+
+# Linux x86_64 (Docker)
+echo "[2/4] Linux x86_64..."
+docker run --rm \
+    -v "$SCRIPT_DIR":/app -w /app \
+    --platform linux/amd64 \
+    rust:slim \
+    bash -c "apt-get update -qq && apt-get install -y -qq pkg-config libssl-dev >/dev/null 2>&1 && cargo build --release -p native-node --no-default-features --target-dir target/docker_linux_amd64 && cp target/docker_linux_amd64/release/native-node /app/frontend/public/download/kipina-node-linux-x86_64"
+echo "      $(ls -lh "$OUT/kipina-node-linux-x86_64" | awk '{print $5}')"
+
+# Linux ARM64 (Docker)
+echo "[3/4] Linux ARM64..."
+docker run --rm \
+    -v "$SCRIPT_DIR":/app -w /app \
+    --platform linux/arm64 \
+    rust:slim \
+    bash -c "apt-get update -qq && apt-get install -y -qq pkg-config libssl-dev >/dev/null 2>&1 && cargo build --release -p native-node --no-default-features --target-dir target/docker_linux_arm64 && cp target/docker_linux_arm64/release/native-node /app/frontend/public/download/kipina-node-linux-arm64"
+echo "      $(ls -lh "$OUT/kipina-node-linux-arm64" | awk '{print $5}')"
+
+# Windows x86_64 (Docker + mingw-w64)
+echo "[4/4] Windows x86_64..."
+docker run --rm \
+    -v "$SCRIPT_DIR":/app -w /app \
+    --platform linux/amd64 \
+    rust:slim \
+    bash -c "apt-get update -qq && apt-get install -y -qq gcc-mingw-w64-x86-64 pkg-config libssl-dev >/dev/null 2>&1 && rustup target add x86_64-pc-windows-gnu && cargo build --release -p native-node --no-default-features --target x86_64-pc-windows-gnu && cp target/x86_64-pc-windows-gnu/release/native-node.exe /app/frontend/public/download/kipina-node-windows-x86_64.exe"
+echo "      $(ls -lh "$OUT/kipina-node-windows-x86_64.exe" | awk '{print $5}')"
+
+# Tallennetaan onnistuneen buildin hash
+echo "$CURRENT_HASH" > "$HASH_FILE"
+
+echo ""
+echo "=== Binäärit valmiina ==="
+ls -lh "$OUT"/kipina-node-*

network-poc/deploy-binaries.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+SERVER="ubuntu@86.50.252.98"
+REMOTE_DIR="~/code/agentic-studio/network-poc"
+KEY="$HOME/.ssh/id_rsa"
+SSH_OPTS="-o StrictHostKeyChecking=no -i $KEY"
+
+if ! ssh-add -l 2>/dev/null | grep -q id_rsa; then
+    echo "SSH-avain ei ole agentissa. Lisätään..."
+    ssh-add "$KEY"
+fi
+
+echo "=== Kipinä Node - Vain Binäärien Päivitys ==="
+
+# 1. Käännetään binäärit (hyödyntää korjattua build-binaries.sh cache logiikkaa)
+"$SCRIPT_DIR/build-binaries.sh"
+
+# 2. Siirretään binäärit suoraan kohdekoneen hakemistoon ohittaen Docker-imagen täyden rakennuksen
+echo ""
+echo "[Vieminen uuteen kohteeseen...]"
+ssh $SSH_OPTS "$SERVER" "mkdir -p $REMOTE_DIR/frontend/dist/download"
+scp $SSH_OPTS "$SCRIPT_DIR/frontend/public/download"/kipina-node-* "$SERVER:$REMOTE_DIR/frontend/dist/download/"
+
+# 3. Luvat kuntoon
+ssh $SSH_OPTS "$SERVER" "chmod +x $REMOTE_DIR/frontend/dist/download/kipina-node-*"
+
+echo "=== Valmis! Binäärit ovat nyt asennettu livenä ja ladattavissa kipina.studiosta ==="

network-poc/deploy-fast.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Nopea deploy: päivittää vain frontendin (ei kontin uudelleenkäynnistystä)
+# Hub-binäärin päivitys: käytä deploy.sh tai deploy-light.sh
+set -e
+
+SERVER="ubuntu@86.50.252.98"
+REMOTE_DIR="~/code/agentic-studio/network-poc"
+SSH_OPTS="-o StrictHostKeyChecking=no"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "=== Kipinä Studio — Frontend Deploy ==="
+
+# 1. Buildaa frontend paikallisesti
+echo "[1/2] Rakennetaan frontend..."
+cd "$SCRIPT_DIR/frontend"
+[ -d node_modules ] || npm install --silent
+npm run build --silent 2>&1 | tail -1
+
+# 2. Synkataan dist/ palvelimelle (vain muuttuneet tiedostot)
+echo "[2/2] Synkataan dist/ → palvelin..."
+ssh $SSH_OPTS $SERVER "mkdir -p $REMOTE_DIR/frontend/dist"
+rsync -az --delete -e "ssh $SSH_OPTS" "$SCRIPT_DIR/frontend/dist/" "$SERVER:$REMOTE_DIR/frontend/dist/"
+
+echo ""
+echo "=== Valmis! Frontend päivitetty — ei uudelleenkäynnistystä ==="
+echo "    https://kipina.studio"
+echo ""
+echo "Huom: Jos Rust-koodi (hub/) muuttui, aja: ./deploy.sh"

network-poc/deploy-light.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Kevyt deploy: lähetetään vain koodi, palvelin buildaa itse
+set -e
+
+SERVER="ubuntu@86.50.252.98"
+REMOTE_DIR="~/code/agentic-studio/network-poc"
+SSH_OPTS="-o StrictHostKeyChecking=no"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "=== Kipinä Studio Deploy (remote build) ==="
+
+# 1. Synkataan koodi palvelimelle (vain muuttuneet tiedostot)
+echo "[1/3] Synkataan koodi..."
+rsync -az --delete \
+    --exclude 'target/' \
+    --exclude 'node_modules/' \
+    --exclude 'dist/' \
+    --exclude '.astro/' \
+    --exclude 'temp/' \
+    --exclude '*.db' \
+    --exclude '.git/' \
+    "$SCRIPT_DIR/" "$SERVER:$REMOTE_DIR/"
+
+# 2. Rakennetaan image palvelimella
+echo "[2/3] Rakennetaan image palvelimella..."
+ssh $SSH_OPTS $SERVER "cd $REMOTE_DIR && docker build -f Dockerfile.prod -t kipina-agentic:latest ."
+
+# 3. Käynnistetään
+echo "[3/3] Käynnistetään..."
+ssh $SSH_OPTS $SERVER "cd $REMOTE_DIR && docker compose -f docker-compose.prod.yml down && docker compose -f docker-compose.prod.yml up -d"
+
+echo "=== Valmis! https://kipina.studio ==="

network-poc/deploy-with-native.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Deploy + native-node-binäärien käännös (jos muutoksia)
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+echo "=== Kipinä Studio Deploy (+ native binäärit) ==="
+
+# Käännetään native-node-binäärit (ohittaa automaattisesti jos ei muutoksia)
+"$SCRIPT_DIR/build-binaries.sh"
+
+# Ajetaan normaali deploy
+exec "$SCRIPT_DIR/deploy.sh"

network-poc/deploy.sh

@@ -40,20 +40,20 @@ echo "[1/4] Rakennetaan image lokaalisti..."
 docker build --platform linux/amd64 -f Dockerfile.prod -t kipina-agentic:latest .
 
 # 2. Tallennetaan tiedostoon
-echo "[2/5] Pakataan image..."
+echo "[2/4] Pakataan image..."
 docker save kipina-agentic:latest | gzip > /tmp/kipina-agentic.tar.gz
 echo "       Koko: $(du -h /tmp/kipina-agentic.tar.gz | cut -f1)"
 
 # 3. Siirretään palvelimelle
-echo "[3/5] Siirretään palvelimelle..."
+echo "[3/4] Siirretään palvelimelle..."
 scp $SSH_OPTS /tmp/kipina-agentic.tar.gz $SERVER:/tmp/
 scp $SSH_OPTS docker-compose.prod.yml Caddyfile.prod $SERVER:$REMOTE_DIR/
 
 # 4. Ladataan image ja käynnistetään
-echo "[4/5] Ladataan image palvelimella..."
+echo "[4/4] Ladataan image palvelimella..."
 ssh $SSH_OPTS $SERVER "gunzip -c /tmp/kipina-agentic.tar.gz | docker load && rm /tmp/kipina-agentic.tar.gz"
 
-echo "[5/5] Käynnistetään palvelut uudelleen..."
+echo "[4/4] Käynnistetään palvelut uudelleen..."
 ssh $SSH_OPTS $SERVER "cd $REMOTE_DIR && docker compose -f docker-compose.prod.yml down && docker compose -f docker-compose.prod.yml up -d"
 
 echo "=== Valmis! https://kipina.studio ==="

network-poc/docker-compose.client.yml

@@ -1,13 +1,12 @@
 services:
-  # NVIDIA GPU -solmu
+  # Ollama NVIDIA GPU:lla
-  native-node-nvidia:
+  ollama-nvidia:
-    build:
+    image: ollama/ollama:latest
-      context: .
+    container_name: kipina-ollama
-      dockerfile: Dockerfile.native-node
+    ports:
-    container_name: kipina-node-nvidia
+      - "11434:11434"
-    environment:
+    volumes:
-      - HUB_URL=wss://kipina.studio/ws
+      - ollama-models:/root/.ollama
-      - ALLOCATED_GB=4
     restart: unless-stopped
     deploy:
       resources:
@@ -16,6 +15,65 @@ services:
             - driver: nvidia
               count: all
               capabilities: [gpu]
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - nvidia
+
+  # Ollama AMD ROCm GPU:lla
+  ollama-amd:
+    image: ollama/ollama:rocm
+    container_name: kipina-ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    restart: unless-stopped
+    devices:
+      - /dev/kfd:/dev/kfd
+      - /dev/dri:/dev/dri
+    group_add:
+      - video
+      - render
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - amd
+
+  # Ollama CPU:lla
+  ollama-cpu:
+    image: ollama/ollama:latest
+    container_name: kipina-ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    restart: unless-stopped
+    networks:
+      default:
+        aliases:
+          - ollama
+    profiles:
+      - cpu
+
+  # NVIDIA GPU -solmu
+  native-node-nvidia:
+    build:
+      context: .
+      dockerfile: Dockerfile.native-node
+    container_name: kipina-node-nvidia
+    environment:
+      - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
+      - ALLOCATED_GB=4
+    restart: unless-stopped
+    depends_on:
+      - ollama-nvidia
     profiles:
       - nvidia
 
@@ -27,14 +85,12 @@ services:
     container_name: kipina-node-amd
     environment:
       - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=4
     restart: unless-stopped
-    devices:
+    depends_on:
-      - /dev/kfd:/dev/kfd
+      - ollama-amd
-      - /dev/dri:/dev/dri
-    group_add:
-      - video
-      - render
     profiles:
       - amd
 
@@ -46,7 +102,14 @@ services:
     container_name: kipina-node-cpu
     environment:
       - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=2
     restart: unless-stopped
+    depends_on:
+      - ollama-cpu
     profiles:
       - cpu
+
+volumes:
+  ollama-models:

network-poc/docker-compose.prod.yml

@@ -19,8 +19,12 @@ services:
     restart: unless-stopped
     environment:
       - DATABASE_PATH=/data/nodes.db
+      - STATIC_DIR=/app/frontend/dist
+      - ADMIN_PASSWORD=${ADMIN_PASSWORD:-}
+      - NODE_API_KEY=${NODE_API_KEY:-}
     volumes:
       - hub_data:/data
+      - ./frontend/dist:/app/frontend/dist:ro
 
 volumes:
   caddy_data:

network-poc/docker-compose.yml

@@ -11,24 +11,37 @@ services:
     # Käännetään aina käynnistyksen yhteydessä varmuuden vuoksi Wasm uusimmista koodeista, ja päälle pyöräytetään Hub!
     command: bash -c "cd node && wasm-pack build --release --target web --out-dir ../static/pkg && cd ../hub && cargo run"
 
-  # Valinnainen natiivi-solmu — kerää oikeat laitteistotiedot (nvidia-smi-taso)
+  # Ollama — LLM-inferenssi
+  # NVIDIA: vaihda image → ollama/ollama:latest ja lisää deploy.resources (ks. README)
+  # CPU: vaihda image → ollama/ollama:latest ja poista devices
+  ollama:
+    image: ollama/ollama:rocm
+    container_name: kipina_ollama
+    ports:
+      - "11434:11434"
+    volumes:
+      - ollama-models:/root/.ollama
+    devices:
+      - /dev/kfd
+      - /dev/dri
+    profiles:
+      - native
+
+  # Natiivisolmu — yhdistää hubiin ja käyttää Ollamaa inferenssiin
   native-node:
     build:
       context: .
       dockerfile: Dockerfile.native-node
     container_name: kipina_native_node
     environment:
-      - HUB_URL=ws://agentic-poc:3000/ws
+      - HUB_URL=wss://kipina.studio/ws
+      - OLLAMA_URL=http://ollama:11434
+      - OLLAMA_MODEL=qwen2.5-coder:7b
       - ALLOCATED_GB=4
     depends_on:
-      - agentic-poc
+      - ollama
-    # GPU passthrough (valinnainen — toimii myös ilman)
-    deploy:
-      resources:
-        reservations:
-          devices:
-            - driver: nvidia
-              count: all
-              capabilities: [gpu]
     profiles:
       - native
+
+volumes:
+  ollama-models:

network-poc/frontend/.gitignore

@@ -0,0 +1,3 @@
+node_modules/
+dist/
+.astro/

network-poc/frontend/astro.config.mjs

@@ -0,0 +1,2 @@
+import { defineConfig } from 'astro/config';
+export default defineConfig({});

network-poc/frontend/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "kipina-frontend",
+  "type": "module",
+  "version": "0.1.0",
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview"
+  },
+  "dependencies": {
+    "astro": "^6.1.5"
+  }
+}

network-poc/frontend/public/GUIDE.md

@@ -36,29 +36,13 @@ sanan osa, kokonainen sana tai välilyönti. Tokenisaatio tehdään
 BPE-algoritmilla (Byte Pair Encoding) joka oppii yleisimmät
 merkkijonot harjoitusdatasta.
 
-### Esimerkki: koodi
-
-```
-"print('Hello')" → [print] [(' ] [Hello] [')]  = 4 tokenia
-"tulosta('Hei')" → [tul] [osta] [(' ] [He] [i] [')]  = 6 tokenia
-```
-
-Koodi tokenisoidaan tehokkaasti koska `print`, `def`, `return` yms.
-ovat kokonaisia tokeneita. Suomenkielinen `tulosta` joudutaan pilkkomaan
-osiin koska se ei esiinny harjoitusdatassa kokonaisena.
-
 ### Esimerkki: suomi vs. englanti
 
-Sama lause kahdella kielellä Qwen2.5-Coder -tokenisaattorilla:
+Alla oikea tokenisointitulos Qwen2.5-Coder-tokenisaattorilla. Jokainen
+värikoodattu lohko on yksi tokeni — huomaa miten suomi vaatii enemmän
+tokeneita saman merkityksen välittämiseen:
 
-| | Teksti | Tokenit | Määrä | Merkkejä/token |
+![Tokenisointivertailu EN/FI](/images/tokenization-example.png)
-|---|---|---|---|---|
-| EN | The cat sat on the mat | [The] [ cat] [ sat] [ on] [ the] [ mat] | **6** | 3.7 |
-| FI | Kissa istui matolla | [K] [issa] [ ist] [ui] [ mat] [olla] | **6** | 3.2 |
-| EN | Distributed computing in the browser | [Dist] [ributed] [ computing] [ in] [ the] [ browser] | **6** | 6.0 |
-| FI | Hajautettu laskenta selaimessa | [H] [aj] [au] [tettu] [ las] [kenta] [ sel] [aim] [essa] | **9** | 3.3 |
-| EN | Write a function that sorts a list | [Write] [ a] [ function] [ that] [ sorts] [ a] [ list] | **7** | 5.0 |
-| FI | Kirjoita funktio joka lajittelee listan | [K] [irj] [oita] [ funkt] [io] [ joka] [ laj] [ittel] [ee] [ listan] | **10** | 4.0 |
 
 **Huomaa miten:**
 - Englannin yleiset sanat (`the`, `in`, `a`, `function`) ovat kokonaisia tokeneita

network-poc/frontend/public/download/.build-hash

@@ -0,0 +1 @@
+403f35efdcdf6317309f2e6b450c0ea257550b6a

network-poc/frontend/public/join.sh

@@ -0,0 +1,73 @@
+#!/bin/bash
+# Kipinä — liitä koneesi laskentaverkkoon
+set -e
+
+HUB_URL="${KIPINA_HUB:-wss://kipina.studio/ws}"
+MODEL="${KIPINA_MODEL:-qwen2.5-coder:3b}"
+
+echo ""
+echo "  ╔══════════════════════════════════════╗"
+echo "  ║  Kipinä Agentic Network — Node Join  ║"
+echo "  ╚══════════════════════════════════════╝"
+echo ""
+
+# 1. Ollama
+if command -v ollama &>/dev/null; then
+    echo "  ✓ Ollama löytyi: $(ollama --version 2>/dev/null || echo 'asennettu')"
+else
+    echo "  Ollama ei ole asennettu."
+    echo ""
+    read -p "  Asennetaanko Ollama? (k/e) " -n 1 -r; echo
+    if [[ $REPLY =~ ^[Kk]$ ]]; then
+        echo "  Asennetaan Ollama..."
+        curl -fsSL https://ollama.ai/install.sh | sh
+    else
+        echo "  Ollama vaaditaan laskentaan. Asenna: https://ollama.ai"
+        exit 1
+    fi
+fi
+
+# 2. Varmistetaan että Ollama on käynnissä
+if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+    echo "  Käynnistetään Ollama..."
+    ollama serve &>/dev/null &
+    sleep 3
+    if ! curl -s http://localhost:11434/api/tags &>/dev/null; then
+        echo "  ✗ Ollama ei käynnistynyt. Aja: ollama serve"
+        exit 1
+    fi
+fi
+echo "  ✓ Ollama käynnissä"
+
+# 3. Malli
+if ollama list 2>/dev/null | grep -q "$MODEL"; then
+    echo "  ✓ Malli $MODEL ladattu"
+else
+    echo "  Ladataan malli $MODEL..."
+    ollama pull "$MODEL"
+fi
+
+# 4. Native-node
+echo ""
+echo "  Yhdistetään hubiin: $HUB_URL"
+echo "  Malli: $MODEL"
+echo "  Ctrl+C pysäyttää"
+echo ""
+
+# Tarkistetaan onko native-node käännetty
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+NATIVE_BIN="$SCRIPT_DIR/target/release/native-node"
+
+if [ -f "$NATIVE_BIN" ]; then
+    HUB_URL="$HUB_URL" OLLAMA_MODEL="$MODEL" "$NATIVE_BIN"
+elif command -v cargo &>/dev/null && [ -f "$SCRIPT_DIR/native-node/Cargo.toml" ]; then
+    echo "  Käännetään native-node..."
+    cd "$SCRIPT_DIR"
+    cargo build --release -p native-node --no-default-features 2>&1 | tail -1
+    HUB_URL="$HUB_URL" OLLAMA_MODEL="$MODEL" "$NATIVE_BIN"
+else
+    echo "  ✗ native-node binääriä ei löydy eikä Rust ole asennettu."
+    echo "  Asenna Rust: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh"
+    echo "  Tai lataa valmis binääri: https://kipina.studio/download"
+    exit 1
+fi

network-poc/frontend/public/kipina-node

@@ -0,0 +1,129 @@
+#!/bin/bash
+# Kipinä Node — lataa oikea binääri ja käynnistä
+set -e
+
+BASE_URL="https://kipina.studio/download"
+HUB_URL="${KIPINA_HUB:-wss://kipina.studio/ws}"
+OLLAMA_URL="${OLLAMA_URL:-http://localhost:11434}"
+
+# Tunnista OS ja arkkitehtuuri
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+
+case "$OS-$ARCH" in
+    darwin-arm64)  BINARY="kipina-node-macos-arm64" ;;
+    darwin-x86_64) BINARY="kipina-node-macos-arm64" ;; # Rosetta
+    linux-x86_64)  BINARY="kipina-node-linux-x86_64" ;;
+    linux-aarch64) BINARY="kipina-node-linux-arm64" ;;
+    *) echo "Ei tuettu: $OS-$ARCH"; exit 1 ;;
+esac
+
+echo ""
+echo "  ╔══════════════════════════════════════╗"
+echo "  ║       Kipinä Agentic Node            ║"
+echo "  ╚══════════════════════════════════════╝"
+echo ""
+echo "  OS: $OS ($ARCH)"
+echo ""
+
+# Etsi Ollama-instanssit
+CANDIDATES=(
+    "http://localhost:11434"
+    "http://127.0.0.1:11434"
+    "http://ollama:11434"
+    "http://host.docker.internal:11434"
+)
+
+# Lisää OLLAMA_URL listaan jos asetettu ja ei jo mukana
+if [ -n "$OLLAMA_URL" ]; then
+    ALREADY=false
+    for c in "${CANDIDATES[@]}"; do
+        [ "$c" = "$OLLAMA_URL" ] && ALREADY=true
+    done
+    $ALREADY || CANDIDATES=("$OLLAMA_URL" "${CANDIDATES[@]}")
+fi
+
+echo "  Etsitään Ollama-instansseja..."
+FOUND=()
+for url in "${CANDIDATES[@]}"; do
+    if curl -s --connect-timeout 1 "$url/api/tags" &>/dev/null; then
+        FOUND+=("$url")
+    fi
+done
+
+if [ ${#FOUND[@]} -eq 0 ]; then
+    # Ei löytynyt — yritä käynnistää lokaali
+    if command -v ollama &>/dev/null; then
+        echo "  Käynnistetään Ollama..."
+        ollama serve &>/dev/null &
+        sleep 3
+        if curl -s --connect-timeout 1 "http://localhost:11434/api/tags" &>/dev/null; then
+            OLLAMA_URL="http://localhost:11434"
+            echo "  ✓ Ollama käynnistetty ($OLLAMA_URL)"
+        else
+            echo "  ✗ Ollaman käynnistys epäonnistui."
+            exit 1
+        fi
+    else
+        echo ""
+        echo "  ✗ Ollamaa ei löytynyt."
+        echo "    Kontti/remote: OLLAMA_URL=http://HOST:11434 ./kipina-node"
+        echo "    Asenna:        curl -fsSL https://ollama.ai/install.sh | sh"
+        exit 1
+    fi
+elif [ ${#FOUND[@]} -eq 1 ]; then
+    OLLAMA_URL="${FOUND[0]}"
+    echo "  ✓ Ollama löytyi: $OLLAMA_URL"
+else
+    echo ""
+    echo "  Löytyi ${#FOUND[@]} Ollama-instanssia:"
+    echo ""
+    for i in "${!FOUND[@]}"; do
+        echo "    $((i+1))) ${FOUND[$i]}"
+    done
+    echo ""
+    read -p "  Valitse [1-${#FOUND[@]}]: " -r CHOICE
+    if [[ "$CHOICE" =~ ^[0-9]+$ ]] && [ "$CHOICE" -ge 1 ] && [ "$CHOICE" -le ${#FOUND[@]} ]; then
+        OLLAMA_URL="${FOUND[$((CHOICE-1))]}"
+    else
+        OLLAMA_URL="${FOUND[0]}"
+        echo "  Käytetään oletusta: $OLLAMA_URL"
+    fi
+    echo "  ✓ Valittu: $OLLAMA_URL"
+fi
+
+echo ""
+echo "  Hub: $HUB_URL"
+echo "  Ollama: $OLLAMA_URL"
+if [ -n "$KIPINA_MODEL" ]; then
+    echo "  Malli: $KIPINA_MODEL (Ympäristömuuttujasta)"
+fi
+
+# Lataa binääri
+BIN_PATH="./kipina-node-bin"
+if [ -f "$BIN_PATH" ]; then
+    echo ""
+    read -p "  Löydettiin vanha kipina-node-bin lokaalisti. Haluatko poistaa sen ja ladata uusimman version? [y/N] " -r DEL_CHOICE
+    if [[ "$DEL_CHOICE" =~ ^[Yy]$ ]]; then
+        rm -f "$BIN_PATH"
+        echo "  ✓ Vanha binääri poistettu."
+    fi
+fi
+
+if [ ! -f "$BIN_PATH" ]; then
+    echo "  Ladataan tuorein $BINARY..."
+    curl -sSL "$BASE_URL/$BINARY" -o "$BIN_PATH"
+    chmod +x "$BIN_PATH"
+fi
+
+echo ""
+echo "  ✓ Siirrytään Kipinä Noden hallintaan..."
+echo "    Ctrl+C pysäyttää"
+echo ""
+
+if [ -n "$KIPINA_MODEL" ]; then
+    export OLLAMA_MODEL="$KIPINA_MODEL"
+fi
+export HUB_URL="$HUB_URL"
+export OLLAMA_URL="$OLLAMA_URL"
+exec "$BIN_PATH"

network-poc/frontend/public/pkg/node.d.ts

@@ -0,0 +1,63 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function set_auto_tasks(enabled: boolean): void;
+
+export function set_gpu_load(load: number): void;
+
+export function start_agent_node(hub_url: string, has_webgpu: boolean, device_info_json: string, task_id: number): Promise<void>;
+
+/**
+ * JS-exportti: tokenisoi tekstin ja palauttaa JSON-merkkijonon
+ * Tokenizer ladataan IndexedDB:stä (täytyy olla ladattu aiemmin)
+ */
+export function tokenize_js(text: string): Promise<string>;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly set_auto_tasks: (a: number) => void;
+    readonly set_gpu_load: (a: number) => void;
+    readonly start_agent_node: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+    readonly tokenize_js: (a: number, b: number) => any;
+    readonly wasm_bindgen__convert__closures_____invoke__h6ec112f0342d232e: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen__convert__closures_____invoke__h737e63bacb96714d: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h9cacd8a9a6ca46c2: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4_3: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a_5: (a: number, b: number, c: any) => void;
+    readonly wasm_bindgen__convert__closures_____invoke__h698aa4c8c2e7db1b: (a: number, b: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

network-poc/frontend/public/pkg/node_bg.wasm.d.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const set_auto_tasks: (a: number) => void;
+export const set_gpu_load: (a: number) => void;
+export const start_agent_node: (a: number, b: number, c: number, d: number, e: number, f: number) => any;
+export const tokenize_js: (a: number, b: number) => any;
+export const wasm_bindgen__convert__closures_____invoke__h6ec112f0342d232e: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h737e63bacb96714d: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h9cacd8a9a6ca46c2: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__ha390eb51fa5285b4_3: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h0afc19def95e993a_5: (a: number, b: number, c: any) => void;
+export const wasm_bindgen__convert__closures_____invoke__h698aa4c8c2e7db1b: (a: number, b: number) => void;
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_destroy_closure: (a: number, b: number) => void;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

network-poc/frontend/public/pkg/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "node",
+  "type": "module",
+  "version": "0.1.0",
+  "files": [
+    "node_bg.wasm",
+    "node.js",
+    "node.d.ts"
+  ],
+  "main": "node.js",
+  "types": "node.d.ts",
+  "sideEffects": [
+    "./snippets/*"
+  ]
+}

network-poc/frontend/public/templates/fastapi-crud.json

@@ -0,0 +1,27 @@
+{
+  "name": "FastAPI CRUD",
+  "description": "REST API with SQLite database",
+  "files": {
+    "models.py": {
+      "description": "SQLAlchemy models, engine, and session",
+      "example": "from sqlalchemy import create_engine, Column, Integer, String\nfrom sqlalchemy.ext.declarative import declarative_base\nfrom sqlalchemy.orm import sessionmaker\n\nDATABASE_URL = \"sqlite:///./app.db\"\nengine = create_engine(DATABASE_URL, connect_args={\"check_same_thread\": False})\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\nBase = declarative_base()\n\nclass Item(Base):\n    __tablename__ = \"items\"\n    id = Column(Integer, primary_key=True, index=True)\n    name = Column(String(100), nullable=False)\n    description = Column(String(500))",
+      "instructions": "Define the SQLAlchemy model based on the project description. Always include:\n- engine with check_same_thread=False for SQLite\n- SessionLocal with autocommit=False\n- Base = declarative_base()\n- Model class with __tablename__, primary key, and fields"
+    },
+    "schemas.py": {
+      "description": "Pydantic request/response schemas",
+      "example": "from pydantic import BaseModel\n\nclass ItemCreate(BaseModel):\n    name: str\n    description: str | None = None\n\nclass ItemResponse(ItemCreate):\n    id: int\n\n    class Config:\n        from_attributes = True",
+      "instructions": "Create Pydantic schemas that match the SQLAlchemy model:\n- Create schema: fields without id (user provides these)\n- Response schema: inherits from Create, adds id\n- Add class Config with from_attributes = True (required for SQLAlchemy ORM)"
+    },
+    "main.py": {
+      "description": "FastAPI app with CRUD endpoints",
+      "example": "from fastapi import FastAPI, Depends, HTTPException\nfrom sqlalchemy.orm import Session\nfrom models import Base, engine, SessionLocal, Item\nfrom schemas import ItemCreate, ItemResponse\n\nBase.metadata.create_all(bind=engine)\napp = FastAPI()\n\ndef get_db():\n    db = SessionLocal()\n    try:\n        yield db\n    finally:\n        db.close()\n\n@app.post(\"/items/\", response_model=ItemResponse, status_code=201)\ndef create_item(item: ItemCreate, db: Session = Depends(get_db)):\n    db_item = Item(**item.model_dump())\n    db.add(db_item)\n    db.commit()\n    db.refresh(db_item)\n    return db_item\n\n@app.get(\"/items/\", response_model=list[ItemResponse])\ndef list_items(db: Session = Depends(get_db)):\n    return db.query(Item).all()\n\n@app.get(\"/items/{item_id}\", response_model=ItemResponse)\ndef get_item(item_id: int, db: Session = Depends(get_db)):\n    item = db.query(Item).filter(Item.id == item_id).first()\n    if not item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    return item\n\n@app.put(\"/items/{item_id}\", response_model=ItemResponse)\ndef update_item(item_id: int, item: ItemCreate, db: Session = Depends(get_db)):\n    db_item = db.query(Item).filter(Item.id == item_id).first()\n    if not db_item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    for key, value in item.model_dump().items():\n        setattr(db_item, key, value)\n    db.commit()\n    db.refresh(db_item)\n    return db_item\n\n@app.delete(\"/items/{item_id}\", status_code=204)\ndef delete_item(item_id: int, db: Session = Depends(get_db)):\n    db_item = db.query(Item).filter(Item.id == item_id).first()\n    if not db_item:\n        raise HTTPException(status_code=404, detail=\"Not found\")\n    db.delete(db_item)\n    db.commit()",
+      "instructions": "Create the FastAPI app with all CRUD endpoints:\n- Import from models.py and schemas.py (use exact class names)\n- create_all(bind=engine) at module level\n- get_db dependency with yield pattern\n- POST (201), GET list, GET by id, PUT, DELETE (204)\n- Use response_model for type safety\n- Use model_dump() not dict() (Pydantic v2)"
+    },
+    "pyproject.toml": {
+      "description": "Project dependencies",
+      "example": "[project]\nname = \"myapp\"\nversion = \"0.1.0\"\nrequires-python = \">=3.11\"\ndependencies = [\n    \"fastapi\",\n    \"uvicorn[standard]\",\n    \"sqlalchemy\",\n]\n\n[project.scripts]\ndev = \"uvicorn main:app --reload\"",
+      "instructions": "Use [project] format (PEP 621, compatible with uv). List dependencies under [project.dependencies]. Add [project.scripts] with dev command. Never use requirements.txt or Poetry format. Run with: uv run uvicorn main:app --reload"
+    }
+  },
+  "order": ["models.py", "schemas.py", "main.py", "pyproject.toml"]
+}

network-poc/frontend/src/components/AgentBar.astro

@@ -0,0 +1,79 @@
+<!-- Agenttigalleria + konfigurointipaneeli -->
+<div style="display:flex;gap:16px;padding:10px 0;align-items:flex-start">
+    <!-- Agenttilista (drag & drop) -->
+    <div id="agent-bar" style="display:flex;gap:6px;align-items:flex-end;flex-wrap:wrap">
+        <!-- Renderöidään JS:stä -->
+    </div>
+    <!-- + Lisää agentti -->
+    <div id="add-agent-btn" class="agent-avatar" onclick="addCustomAgent()" title="Lisää oma agentti" style="opacity:0.4">
+        <div style="width:48px;height:48px;border-radius:50%;border:2px dashed var(--border);display:flex;align-items:center;justify-content:center;font-size:24px;color:var(--border)">+</div>
+        <span style="font-size:10px;color:#8b949e;text-align:center;display:block">Lisää</span>
+    </div>
+</div>
+
+<!-- Agentin konfigurointipaneeli (avautuu klikkaamalla avataria) -->
+<div id="agent-config" style="display:none;background:var(--panel);border:1px solid var(--border);border-radius:6px;padding:16px;margin-bottom:10px">
+    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
+        <div style="display:flex;align-items:center;gap:10px">
+            <img id="config-avatar" src="" style="width:40px;height:40px;border-radius:50%">
+            <div>
+                <input id="config-name" style="background:transparent;border:none;color:var(--text);font-size:16px;font-weight:600;outline:none;width:200px" placeholder="Agentin nimi">
+                <div id="config-role" style="font-size:11px;color:#8b949e"></div>
+            </div>
+        </div>
+        <div style="display:flex;gap:6px">
+            <button class="btn btn-red" onclick="deleteAgent()" title="Poista agentti">Poista</button>
+            <button class="btn btn-muted" onclick="closeAgentConfig()">Sulje</button>
+        </div>
+    </div>
+
+    <!-- Malli -->
+    <div style="margin-bottom:10px">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px">Kielimalli</label>
+        <select id="config-model" style="background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:4px;padding:6px 10px;font-size:13px;width:100%">
+            <option value="qwen-coder">Qwen2.5-Coder:0.5B (selain)</option>
+            <option value="qwen-coder-3b">Qwen2.5-Coder:3B (Ollama)</option>
+            <option value="qwen2.5-coder:7b">Qwen2.5-Coder:7B (Ollama)</option>
+            <option value="qwen2.5-coder:1.5b">Qwen2.5-Coder:1.5B (Ollama)</option>
+        </select>
+    </div>
+
+    <!-- System prompt -->
+    <div style="margin-bottom:10px" title="Agentin perusohje joka lähetetään kielimallille jokaisessa pyynnössä.&#10;&#10;Hyvän promptin rakenne:&#10;1. Rooli: 'You are an expert...'&#10;2. Säännöt: RULES/CRITICAL RULES listana&#10;3. Esimerkit: EXAMPLE OUTPUT&#10;4. Kiellot: NEVER-lista&#10;&#10;Vinkki: käytä englantia — malli ymmärtää sen paremmin ja se kuluttaa vähemmän tokeneita.">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px;cursor:help">System prompt 💡</label>
+        <textarea id="config-prompt" style="width:100%;background:var(--bg);color:var(--text);border:1px solid var(--border);border-radius:4px;padding:8px;font-size:13px;font-family:'Courier New',monospace;resize:vertical;overflow:hidden;min-height:60px" placeholder="Kuvaa agentin rooli ja käyttäytyminen..."></textarea>
+    </div>
+
+    <!-- Sampling-parametrit -->
+    <div style="margin-bottom:10px">
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:8px">Sampling-parametrit</label>
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:10px">
+            <div title="Kontrolloi 'luovuutta'. Matala arvo (0.2-0.4) tuottaa ennustettavaa, toistettavaa koodia — hyvä testaajille ja reviewereille. Keskiarvo (0.6-0.8) on paras koodin generointiin. Korkea arvo (1.0+) lisää vaihtelua mutta myös virheitä.&#10;&#10;Suositus:&#10;• Manageri: 0.5 (tarkat tiedostolistat)&#10;• Koodari: 0.7 (toimiva koodi + vaihtelu)&#10;• Testaaja: 0.3 (deterministinen arviointi)">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Temperature 💡 <span id="config-temp-val" style="color:var(--accent);float:right">0.7</span></label>
+                <input type="range" id="config-temperature" min="0" max="1.5" step="0.1" value="0.7" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">0=tarkka · 0.7=oletus · 1.5=luova</div>
+            </div>
+            <div title="Vastauksen maksimipituus tokeneina (~1 token ≈ 4 merkkiä).&#10;&#10;Suositus:&#10;• Manageri: 256-512 (lyhyet tiedostolistat)&#10;• Koodari: 1024-2048 (täydet tiedostot, CRUD-endpointit)&#10;• Testaaja: 256-512 (lyhyet arvioinnit)&#10;&#10;Jos koodi katkeaa kesken, nosta tätä. Jos malli tuottaa turhaa toistoa, laske.">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Max tokens 💡 <span id="config-maxtok-val" style="color:var(--accent);float:right">1024</span></label>
+                <input type="range" id="config-maxtokens" min="64" max="4096" step="64" value="1024" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">Vastauksen maksimipituus</div>
+            </div>
+            <div title="Montako todennäköisintä tokenia huomioidaan valinnassa. Pieni arvo (1-10) tekee vastauksesta deterministisen. Suuri arvo (50-100) sallii harvinaisempia sanoja.&#10;&#10;Suositus:&#10;• Boilerplate-koodi: 20-30 (tutut patternit)&#10;• Yleiskoodi: 40 (hyvä oletus)&#10;• Luova teksti: 60-80&#10;&#10;Yleensä ei tarvitse muuttaa oletuksesta.">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Top-K 💡 <span id="config-topk-val" style="color:var(--accent);float:right">40</span></label>
+                <input type="range" id="config-topk" min="1" max="100" step="1" value="40" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">1=greedy · 40=oletus · 100=laaja</div>
+            </div>
+            <div title="Vähentää jo tuotettujen sanojen todennäköisyyttä. Estää mallia toistamasta samaa lausetta. Liian korkea arvo (>1.5) voi rikkoa koodin koska samat avainsanat (return, if, def) ovat tarpeellisia.&#10;&#10;Suositus:&#10;• Koodi: 1.1-1.2 (lievä, sallii toiston)&#10;• Teksti: 1.15-1.3 (vahvempi)&#10;• Review: 1.0-1.1 (ei rangaistusta, lyhyet vastaukset)">
+                <label style="font-size:11px;color:#8b949e;cursor:help">Repetition penalty 💡 <span id="config-rep-val" style="color:var(--accent);float:right">1.15</span></label>
+                <input type="range" id="config-repeat" min="1.0" max="2.0" step="0.05" value="1.15" style="width:100%;accent-color:var(--accent)">
+                <div style="font-size:10px;color:#30363d">1.0=ei · 1.15=oletus · 2.0=vahva</div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Pipeline-järjestys -->
+    <div>
+        <label style="font-size:12px;color:#8b949e;display:block;margin-bottom:4px">Pipeline-järjestys <span style="color:var(--border)">(vedä järjestääksesi)</span></label>
+        <div id="config-pipeline" style="display:flex;gap:4px;flex-wrap:wrap"></div>
+    </div>
+</div>

network-poc/frontend/src/components/Editor.astro

@@ -0,0 +1,15 @@
+<!-- Monaco Editor paneeli -->
+<div id="panel-editor" class="panel">
+    <div style="display:flex;height:calc(100vh - 200px);gap:0;border:1px solid var(--border);border-radius:6px;overflow:hidden">
+        <div id="editor-filetree" style="width:200px;min-width:150px;background:var(--bg);border-right:1px solid var(--border);overflow-y:auto;font-family:'Courier New',monospace;font-size:13px">
+            <div style="padding:10px 12px;color:#8b949e;font-size:11px;text-transform:uppercase;letter-spacing:0.5px;border-bottom:1px solid var(--border)">Tiedostot</div>
+            <div id="editor-file-list" style="padding:4px 0">
+                <div style="padding:8px 16px;color:#8b949e;font-size:12px">Generoi projekti:<br><code style="color:var(--accent)">kpn project "..."</code></div>
+            </div>
+        </div>
+        <div style="flex:1;display:flex;flex-direction:column">
+            <div id="editor-tabs" style="display:flex;background:var(--bg);border-bottom:1px solid var(--border);min-height:35px;align-items:flex-end;padding:0 8px;gap:2px;overflow-x:auto"></div>
+            <div id="monaco-container" style="flex:1"></div>
+        </div>
+    </div>
+</div>

network-poc/frontend/src/components/Guide.astro

@@ -0,0 +1,6 @@
+<!-- Opas-paneeli: ladataan GUIDE.md fetchillä -->
+<div id="panel-guide" class="panel">
+    <div id="guide-content" style="max-width:800px;margin:0 auto;padding:20px;line-height:1.7;font-size:15px">
+        <p style="color:#8b949e">Ladataan opasta...</p>
+    </div>
+</div>

network-poc/frontend/src/components/Settings.astro

@@ -0,0 +1,67 @@
+<!-- Asetukset-paneeli: kaikki LLM-parametrit muokattavissa -->
+<div id="panel-settings" class="panel">
+    <div style="max-width:800px;margin:0 auto;padding:20px">
+        <h2 style="color:#e6edf3;margin-bottom:16px">Asetukset</h2>
+        <p style="color:#8b949e;margin-bottom:20px;font-size:14px">Kaikki kielimallin toimintaan vaikuttavat parametrit. Muutokset tallentuvat automaattisesti.</p>
+
+        <!-- System prompt -->
+        <div class="settings-section">
+            <h3 class="settings-title">System Prompt</h3>
+            <p class="settings-desc">Kielimallin perusohje joka lähetetään jokaisessa pyynnössä. Määrittää mallin käyttäytymisen.</p>
+            <textarea id="set-system-prompt" class="settings-textarea" rows="4"></textarea>
+        </div>
+
+        <!-- Sampling -->
+        <div class="settings-section">
+            <h3 class="settings-title">Sampling-parametrit</h3>
+            <p class="settings-desc">Kontrolloi miten malli valitsee seuraavan tokenin. <a href="#guide" onclick="switchTab('guide')" style="color:var(--accent)">Lue lisää oppaasta.</a></p>
+            <div class="settings-grid">
+                <div>
+                    <label class="settings-label">Temperature <span id="set-temp-val" class="settings-val">0.7</span></label>
+                    <input type="range" id="set-temperature" min="0" max="1.5" step="0.1" value="0.7" class="settings-slider">
+                    <div class="settings-hint">0 = deterministic, 0.7 = balanced, 1.5 = creative</div>
+                </div>
+                <div>
+                    <label class="settings-label">Top-K <span id="set-topk-val" class="settings-val">40</span></label>
+                    <input type="range" id="set-topk" min="1" max="100" step="1" value="40" class="settings-slider">
+                    <div class="settings-hint">Montako tokenia huomioidaan. 1 = greedy, 40 = oletus</div>
+                </div>
+                <div>
+                    <label class="settings-label">Repetition Penalty <span id="set-rep-val" class="settings-val">1.15</span></label>
+                    <input type="range" id="set-repeat" min="1.0" max="2.0" step="0.05" value="1.15" class="settings-slider">
+                    <div class="settings-hint">Estää toistoa. 1.0 = ei rangaistusta, 1.15 = oletus</div>
+                </div>
+                <div>
+                    <label class="settings-label">Max Tokens <span id="set-maxtok-val" class="settings-val">1024</span></label>
+                    <input type="range" id="set-maxtokens" min="64" max="4096" step="64" value="1024" class="settings-slider">
+                    <div class="settings-hint">Vastauksen maksimipituus tokeneina</div>
+                </div>
+            </div>
+        </div>
+
+        <!-- Stop-sekvenssit -->
+        <div class="settings-section">
+            <h3 class="settings-title">Stop-sekvenssit</h3>
+            <p class="settings-desc">Generointi katkeaa kun malli tuottaa jonkin näistä. Yksi per rivi.</p>
+            <textarea id="set-stop-sequences" class="settings-textarea" rows="4"></textarea>
+        </div>
+
+        <!-- Malli -->
+        <div class="settings-section">
+            <h3 class="settings-title">Malli (Ollama)</h3>
+            <p class="settings-desc">Natiivisolmun käyttämä kielimalli. Muutos vaatii native-noden uudelleenkäynnistyksen.</p>
+            <select id="set-model" class="settings-select">
+                <option value="qwen2.5-coder:1.5b">Qwen2.5-Coder:1.5B (~80 tok/s, ~1GB)</option>
+                <option value="qwen2.5-coder:3b">Qwen2.5-Coder:3B (~50 tok/s, ~2GB)</option>
+                <option value="qwen2.5-coder:7b-instruct-q4_K_M">Qwen2.5-Coder:7B Q4 (~30 tok/s, ~4GB)</option>
+                <option value="qwen2.5-coder:7b">Qwen2.5-Coder:7B (~20 tok/s, ~7GB)</option>
+            </select>
+        </div>
+
+        <!-- Reset -->
+        <div style="margin-top:24px;padding-top:16px;border-top:1px solid var(--border)">
+            <button class="btn btn-red" onclick="resetSettings()" style="padding:6px 16px">Palauta oletukset</button>
+            <span style="color:#8b949e;font-size:12px;margin-left:8px">Palauttaa kaikki parametrit oletusarvoihin</span>
+        </div>
+    </div>
+</div>

network-poc/frontend/src/components/StatusBar.astro

@@ -0,0 +1,48 @@
+<!-- Hub-yhteys + laskentasolmun tila -->
+<div class="status-bar">
+    <span class="status-group" title="Hub-yhteyden tila">
+        <span id="hub-dot" class="status-dot" style="background:#d29922"></span>
+        <span style="color:#8b949e">Hub:</span>
+        <span id="hub-label" style="color:#d29922">Yhdistetään...</span>
+    </span>
+    <span class="status-separator">│</span>
+    <span class="status-group">
+        <span id="compute-dot" class="status-dot" style="background:#30363d"></span>
+        <span style="color:#8b949e">Laskenta:</span>
+        <span id="compute-label" style="color:#8b949e">—</span>
+        <button id="compute-btn" class="btn btn-accent" title="Käynnistä kielimalli selaimessa">Alusta</button>
+    </span>
+    <span class="status-separator">│</span>
+    <span class="status-group">
+        <button id="join-btn" class="btn btn-green" onclick="showJoinDialog()" title="Liitä oma koneesi laskentaverkkoon (natiivi, nopea)">+ Liitä koneesi</button>
+    </span>
+</div>
+
+<!-- Join-dialogi -->
+<div id="join-dialog" style="display:none;margin-top:8px;padding:16px;background:var(--panel);border:1px solid var(--border);border-radius:6px;font-size:14px">
+    <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px">
+        <span style="color:#e6edf3;font-weight:600;font-size:16px">Liitä koneesi laskentaverkkoon</span>
+        <button onclick="document.getElementById('join-dialog').style.display='none'" style="background:none;border:none;color:#8b949e;cursor:pointer;font-size:18px">✕</button>
+    </div>
+    <p style="color:#8b949e;margin-bottom:16px">Koneesi suorittaa tehtäviä ~10-50x nopeammin kuin selainlaskenta. Kaksi vaihetta:</p>
+
+    <!-- Vaihe 1: Ollama -->
+    <div style="margin-bottom:14px;padding:12px;background:var(--bg);border-radius:4px;border-left:3px solid var(--accent)">
+        <div style="color:#e6edf3;font-weight:600;margin-bottom:6px">1. Asenna Ollama <span style="color:#8b949e;font-weight:normal">(kielimallimoottori)</span></div>
+        <div style="display:flex;gap:6px;align-items:center;margin-bottom:6px">
+            <code style="flex:1;background:#010409;padding:8px 12px;border-radius:4px;color:var(--green);font-family:'Courier New',monospace;font-size:13px;user-select:all">curl -fsSL https://ollama.ai/install.sh | sh</code>
+            <button onclick="navigator.clipboard.writeText('curl -fsSL https://ollama.ai/install.sh | sh');this.textContent='✓';setTimeout(()=>this.textContent='Kopioi',1500)" class="btn btn-accent" style="padding:6px 10px">Kopioi</button>
+        </div>
+        <div style="color:#8b949e;font-size:12px">macOS: <code style="color:var(--accent)">brew install ollama</code> · Windows: <a href="https://ollama.ai/download" target="_blank" style="color:var(--accent)">ollama.ai/download</a> · Jos jo asennettu → siirry vaiheeseen 2.</div>
+    </div>
+
+    <!-- Vaihe 2: Kipinä-node -->
+    <div style="padding:12px;background:var(--bg);border-radius:4px;border-left:3px solid var(--green)">
+        <div style="color:#e6edf3;font-weight:600;margin-bottom:6px">2. Käynnistä Kipinä-node</div>
+        <div style="display:flex;gap:6px;align-items:center;margin-bottom:6px">
+            <code style="flex:1;background:#010409;padding:8px 12px;border-radius:4px;color:var(--green);font-family:'Courier New',monospace;font-size:13px;user-select:all">curl -sSL https://kipina.studio/kipina-node -o kipina-node && chmod +x kipina-node && ./kipina-node</code>
+            <button onclick="navigator.clipboard.writeText('curl -sSL https://kipina.studio/kipina-node -o kipina-node && chmod +x kipina-node && ./kipina-node');this.textContent='✓';setTimeout(()=>this.textContent='Kopioi',1500)" class="btn btn-green" style="padding:6px 10px">Kopioi</button>
+        </div>
+        <div style="color:#8b949e;font-size:12px">Lataa kielimallin (~2GB) automaattisesti ensimmäisellä kerralla. Ctrl+C pysäyttää.</div>
+    </div>
+</div>

network-poc/frontend/src/components/Terminal.astro

@@ -0,0 +1,10 @@
+<!-- Pipeline-palkki + Terminaali + Input -->
+<div id="pipeline-bar" class="pipeline-bar"></div>
+<div id="terminal" class="terminal"></div>
+<div class="terminal-input-row">
+    <span class="terminal-prompt">$</span>
+    <input id="term-input" class="terminal-input" type="text"
+        placeholder='kpn run coder "hello world in python"'
+        spellcheck="false" autocomplete="off">
+    <div id="term-dropdown" class="terminal-dropdown"></div>
+</div>

network-poc/frontend/src/styles/global.css

@@ -0,0 +1,200 @@
+:root {
+    --bg: #0d1117;
+    --panel: #161b22;
+    --text: #c9d1d9;
+    --accent: #58a6ff;
+    --green: #3fb950;
+    --yellow: #d29922;
+    --red: #f85149;
+    --purple: #a371f7;
+    --border: #30363d;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    font-size: 16px;
+    background: var(--bg);
+    color: var(--text);
+    min-height: 100vh;
+}
+
+.container { max-width: 1600px; margin: 0 auto; padding: 20px 40px; }
+
+/* Tabs */
+.tabs { display: flex; gap: 4px; margin-bottom: 16px; }
+.tab {
+    padding: 10px 20px; border-radius: 6px 6px 0 0; cursor: pointer;
+    border: 1px solid var(--border); border-bottom: none;
+    background: var(--bg); color: #8b949e; font-size: 15px;
+}
+.tab.active { background: var(--panel); color: var(--accent); border-color: var(--border); }
+
+/* Panels */
+.panel { display: none; }
+.panel.active { display: block; }
+
+/* Status bar */
+.status-bar {
+    display: flex; align-items: center; gap: 12px;
+    padding: 10px 16px; background: var(--bg);
+    border: 1px solid var(--border); border-radius: 6px 6px 0 0;
+    font-family: 'Courier New', monospace; font-size: 14px;
+}
+.status-dot {
+    width: 8px; height: 8px; border-radius: 50%; display: inline-block;
+}
+.status-group { display: flex; align-items: center; gap: 6px; }
+.status-separator { color: var(--border); }
+
+/* Terminal */
+.terminal {
+    background: #010409; border: 1px solid var(--border); border-top: none;
+    font-family: 'Courier New', monospace; font-size: 16px;
+    min-height: 400px; max-height: 70vh; overflow-y: auto;
+    padding: 12px 16px;
+}
+.terminal-line { padding: 1px 0; white-space: pre-wrap; word-break: break-word; }
+.terminal-prompt { color: var(--yellow); margin-right: 8px; }
+.terminal-input-row {
+    display: flex; align-items: center; position: relative;
+    background: #0d1117; border: 1px solid var(--accent); border-top: none;
+    border-radius: 0 0 6px 6px; padding: 10px 14px;
+    font-family: 'Courier New', monospace; font-size: 15px;
+    box-shadow: 0 2px 8px rgba(88,166,255,0.1);
+}
+.terminal-input {
+    flex: 1; background: transparent; border: none; outline: none;
+    color: var(--green); font-family: inherit; font-size: 16px;
+}
+.terminal-dropdown {
+    display: none; position: absolute; bottom: 100%; left: 30px;
+    background: var(--panel); border: 1px solid var(--border);
+    border-radius: 6px; max-height: 200px; overflow-y: auto;
+    font-size: 13px; min-width: 200px; z-index: 100;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.4);
+}
+.dd-item {
+    padding: 6px 12px; cursor: pointer; color: var(--text);
+    white-space: nowrap; border-bottom: 1px solid #21262d;
+}
+.dd-item:hover, .dd-item.active { background: var(--border); color: var(--accent); }
+
+/* Pipeline progress */
+.pipeline-bar {
+    display: none; padding: 8px 14px; background: var(--bg);
+    border: 1px solid var(--border); border-top: none;
+    font-family: 'Courier New', monospace; font-size: 12px;
+    overflow-x: auto; white-space: nowrap;
+}
+
+/* Project card */
+.project-card {
+    margin: 8px 0; border: 1px solid var(--border);
+    border-radius: 6px; background: var(--panel); overflow: hidden;
+}
+.project-header {
+    display: flex; align-items: center; justify-content: space-between;
+    padding: 8px 12px; background: var(--bg); border-bottom: 1px solid var(--border);
+}
+.project-tabs { display: flex; gap: 2px; padding: 6px 8px 0; background: var(--bg); }
+.project-tab {
+    padding: 4px 10px; cursor: pointer; border-radius: 4px 4px 0 0;
+    font-size: 12px; color: #8b949e;
+}
+.project-tab.active { background: var(--panel); color: var(--accent); border: 1px solid var(--border); border-bottom: none; }
+
+/* Buttons */
+.btn {
+    padding: 2px 10px; border-radius: 4px;
+    border: 1px solid var(--border); background: var(--panel);
+    font-size: 12px; font-family: inherit; cursor: pointer;
+}
+.btn-accent { color: var(--accent); }
+.btn-green { color: var(--green); border-color: var(--green); }
+.btn-red { color: var(--red); border-color: var(--red); }
+.btn-muted { color: #8b949e; background: none; }
+
+/* Code display */
+.code-block {
+    font-family: 'Courier New', monospace; background: #010409;
+    border: 1px solid var(--border); border-radius: 6px;
+    padding: 14px; font-size: 13px; line-height: 1.6;
+    white-space: pre-wrap; overflow-x: auto; max-height: 400px; overflow-y: auto;
+}
+.code-block .hljs { background: transparent; padding: 0; }
+
+/* Agent avatars */
+.agent-avatar {
+    background: linear-gradient(145deg, rgba(33,38,45,0.4) 0%, rgba(13,17,23,0.8) 100%);
+    backdrop-filter: blur(12px);
+    border: 1px solid rgba(240,246,252,0.1);
+    border-radius: 14px;
+    padding: 8px 8px 6px;
+    text-align: center;
+    width: 90px;
+    opacity: 0.8;
+    cursor: pointer;
+    transition: all 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+    box-shadow: 0 4px 8px rgba(0,0,0,0.3);
+}
+.agent-avatar:hover {
+    opacity: 0.85;
+    transform: translateY(-2px) scale(1.02);
+    border-color: rgba(240,246,252,0.3);
+    box-shadow: 0 8px 14px rgba(0,0,0,0.4);
+}
+.agent-avatar img {
+    width: 64px; height: 64px; border-radius: 14px;
+    margin-bottom: 4px; border: 2px solid rgba(240,246,252,0.1);
+    transition: all 0.4s ease; object-fit: cover;
+}
+.agent-avatar .avatar-name {
+    font-size: 11px; color: #8b949e; white-space: nowrap;
+    overflow: hidden; text-overflow: ellipsis;
+}
+.agent-avatar.active {
+    opacity: 1;
+    transform: translateY(-8px) scale(1.05);
+    border-color: var(--accent);
+    background: linear-gradient(145deg, rgba(88,166,255,0.15) 0%, rgba(13,17,23,0.9) 100%);
+    box-shadow: 0 16px 24px rgba(0,0,0,0.5), 0 0 20px rgba(88,166,255,0.3);
+    z-index: 2;
+}
+.agent-avatar.active img {
+    border-color: var(--accent);
+    box-shadow: 0 0 25px rgba(88,166,255,0.8);
+}
+
+/* Settings */
+.settings-section {
+    margin-bottom: 24px; padding: 16px; background: var(--panel);
+    border: 1px solid var(--border); border-radius: 6px;
+}
+.settings-title { color: #e6edf3; font-size: 15px; margin-bottom: 4px; }
+.settings-desc { color: #8b949e; font-size: 13px; margin-bottom: 12px; }
+.settings-label { color: var(--text); font-size: 13px; display: block; margin-bottom: 4px; }
+.settings-val { color: var(--accent); font-weight: 600; float: right; }
+.settings-hint { color: #8b949e; font-size: 11px; margin-top: 2px; }
+.settings-textarea {
+    width: 100%; background: var(--bg); color: var(--text);
+    border: 1px solid var(--border); border-radius: 4px;
+    padding: 8px; font-size: 13px; font-family: 'Courier New', monospace;
+    resize: vertical;
+}
+.settings-select {
+    width: 100%; background: var(--bg); color: var(--text);
+    border: 1px solid var(--border); border-radius: 4px;
+    padding: 8px; font-size: 13px;
+}
+.settings-slider {
+    width: 100%; accent-color: var(--accent);
+}
+.settings-grid {
+    display: grid; grid-template-columns: 1fr 1fr; gap: 16px;
+}
+
+/* Animations */
+@keyframes blink { 0%,100% { opacity:1 } 50% { opacity:0 } }
+@keyframes spin { to { transform: rotate(360deg) } }

network-poc/frontend/tsconfig.json

@@ -0,0 +1 @@
+{ "extends": "astro/tsconfigs/strict" }

network-poc/hub-local.log

@@ -0,0 +1,7 @@
+    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.14s
+     Running `target/debug/hub`
+2026-04-12T03:21:35.058711Z  INFO hub: Tietokanta alustettu
+2026-04-12T03:21:35.061635Z  INFO hub: Kipinä Agent Hub v0.3.1 käynnistyy osoitteessa http://localhost:3000
+2026-04-12T03:21:49.577628Z  INFO hub: Solmu 1 yhdistyi osoitteesta 127.0.0.1
+2026-04-12T03:21:49.600021Z  INFO hub: Solmu 1 (natiivi) | 127.0.0.1 | Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM | varaus: 4 GB
+2026-04-12T03:21:49.600099Z  INFO hub:   GPU 0: Apple M2 Max | VRAM: 0/24576 MB | 0°C | 0%

network-poc/hub/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hub"
-version = "0.2.0"
+version = "0.3.1"
 edition = "2024"
 
 [dependencies]
@@ -16,3 +16,4 @@ futures = "0.3"
 rusqlite = { version = "0.31", features = ["bundled"] }
 chrono = "0.4"
 base64 = "0.22"
+reqwest = { version = "0.12", features = ["json"] }

network-poc/hub/src/db.rs

@@ -26,6 +26,36 @@ impl NodeDb {
                 INSERT INTO _schema_version VALUES (2);
             ");
         }
+        if version < 3 {
+            let _ = conn.execute_batch("
+                CREATE TABLE IF NOT EXISTS agents (
+                    id TEXT PRIMARY KEY,
+                    name TEXT NOT NULL,
+                    avatar TEXT NOT NULL DEFAULT '/avatars/kipina_notext.png',
+                    role TEXT NOT NULL DEFAULT 'coder',
+                    model TEXT NOT NULL DEFAULT 'qwen2.5-coder:7b',
+                    color TEXT NOT NULL DEFAULT '#3fb950',
+                    docs TEXT,
+                    prompt TEXT NOT NULL DEFAULT '',
+                    temperature REAL DEFAULT 0.7,
+                    top_k INTEGER DEFAULT 40,
+                    max_tokens INTEGER DEFAULT 512,
+                    repetition_penalty REAL DEFAULT 1.15,
+                    is_default BOOLEAN DEFAULT 0,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+                DELETE FROM _schema_version;
+                INSERT INTO _schema_version VALUES (3);
+            ");
+        }
+        if version < 4 {
+            let _ = conn.execute_batch("
+                ALTER TABLE node_sessions ADD COLUMN is_paused BOOLEAN DEFAULT 0;
+                DELETE FROM _schema_version;
+                INSERT INTO _schema_version VALUES (4);
+            ");
+        }
 
         conn.execute_batch("
             CREATE TABLE IF NOT EXISTS node_sessions (
@@ -61,7 +91,10 @@ impl NodeDb {
                 has_webgpu BOOLEAN,
 
                 -- Tehtävätilastot
-                tasks_completed INTEGER DEFAULT 0
+                tasks_completed INTEGER DEFAULT 0,
+                
+                -- Ohjaustilat
+                is_paused BOOLEAN DEFAULT 0
             );
 
             CREATE TABLE IF NOT EXISTS pair_results (
@@ -160,6 +193,14 @@ impl NodeDb {
         );
     }
 
+    pub fn update_session_status(&self, node_id: u64, is_paused: bool) {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let _ = conn.execute(
+            "UPDATE node_sessions SET is_paused = ?1 WHERE node_id = ?2 AND disconnected_at IS NULL",
+            params![is_paused as i64, node_id as i64],
+        );
+    }
+
     /// Sulkee saman IP:n viewer-sessiot kun aktiivinen node liittyy
     pub fn close_viewers_by_ip(&self, ip: &str) {
         let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
@@ -193,7 +234,7 @@ impl NodeDb {
             "SELECT id, node_id, ip, node_type, connected_at, disconnected_at,
                     platform, hostname, os, cpu_cores, cpu_model, ram_mb,
                     gpu_name, gpu_vendor, gpu_backend, vram_total_mb, gpu_temp_c, gpu_util_pct,
-                    allocated_gb, selected_task, has_webgpu, tasks_completed
+                    allocated_gb, selected_task, has_webgpu, tasks_completed, is_paused
              FROM node_sessions ORDER BY id DESC LIMIT ?1"
         ).unwrap();
 
@@ -221,6 +262,7 @@ impl NodeDb {
                 "selected_task": row.get::<_, Option<String>>(19)?,
                 "has_webgpu": row.get::<_, Option<bool>>(20)?,
                 "tasks_completed": row.get::<_, i64>(21)?,
+                "is_paused": row.get::<_, Option<bool>>(22)?.unwrap_or(false),
             }))
         }).unwrap().filter_map(|r| r.ok()).collect()
     }
@@ -279,6 +321,82 @@ impl NodeDb {
         })
     }
 
+    // ── Agents CRUD ──
+
+    pub fn upsert_agent(&self, agent: &serde_json::Value) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let now = chrono::Utc::now().to_rfc3339();
+        let id = agent.get("id").and_then(|v| v.as_str()).ok_or("id puuttuu")?;
+        let name = agent.get("name").and_then(|v| v.as_str()).ok_or("name puuttuu")?;
+        conn.execute(
+            "INSERT INTO agents (id, name, avatar, role, model, color, docs, prompt,
+                temperature, top_k, max_tokens, repetition_penalty, is_default, created_at, updated_at)
+             VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?14)
+             ON CONFLICT(id) DO UPDATE SET
+                name=?2, avatar=?3, role=?4, model=?5, color=?6, docs=?7, prompt=?8,
+                temperature=?9, top_k=?10, max_tokens=?11, repetition_penalty=?12, updated_at=?14",
+            params![
+                id, name,
+                agent.get("avatar").and_then(|v| v.as_str()).unwrap_or("/avatars/kipina_notext.png"),
+                agent.get("role").and_then(|v| v.as_str()).unwrap_or("coder"),
+                agent.get("model").and_then(|v| v.as_str()).unwrap_or("qwen2.5-coder:7b"),
+                agent.get("color").and_then(|v| v.as_str()).unwrap_or("#3fb950"),
+                agent.get("docs").and_then(|v| v.as_str()),
+                agent.get("prompt").and_then(|v| v.as_str()).unwrap_or(""),
+                agent.get("temperature").and_then(|v| v.as_f64()).unwrap_or(0.7),
+                agent.get("top_k").and_then(|v| v.as_u64()).unwrap_or(40) as i64,
+                agent.get("max_tokens").and_then(|v| v.as_u64()).unwrap_or(512) as i64,
+                agent.get("repetition_penalty").and_then(|v| v.as_f64()).unwrap_or(1.15),
+                agent.get("is_default").and_then(|v| v.as_bool()).unwrap_or(false),
+                now,
+            ],
+        ).map_err(|e| format!("Agent upsert: {}", e))?;
+        Ok(())
+    }
+
+    pub fn get_agents(&self) -> Vec<serde_json::Value> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let mut stmt = conn.prepare(
+            "SELECT id, name, avatar, role, model, color, docs, prompt,
+                    temperature, top_k, max_tokens, repetition_penalty, is_default,
+                    created_at, updated_at
+             FROM agents ORDER BY is_default DESC, name"
+        ).unwrap();
+
+        stmt.query_map([], |row| {
+            Ok(serde_json::json!({
+                "id": row.get::<_, String>(0)?,
+                "name": row.get::<_, String>(1)?,
+                "avatar": row.get::<_, String>(2)?,
+                "role": row.get::<_, String>(3)?,
+                "model": row.get::<_, String>(4)?,
+                "color": row.get::<_, String>(5)?,
+                "docs": row.get::<_, Option<String>>(6)?,
+                "prompt": row.get::<_, String>(7)?,
+                "temperature": row.get::<_, f64>(8)?,
+                "top_k": row.get::<_, i64>(9)?,
+                "max_tokens": row.get::<_, i64>(10)?,
+                "repetition_penalty": row.get::<_, f64>(11)?,
+                "is_default": row.get::<_, bool>(12)?,
+                "created_at": row.get::<_, String>(13)?,
+                "updated_at": row.get::<_, String>(14)?,
+            }))
+        }).unwrap().filter_map(|r| r.ok()).collect()
+    }
+
+    pub fn delete_agent(&self, id: &str) -> Result<(), String> {
+        let conn = self.conn.lock().unwrap_or_else(|e| e.into_inner());
+        let deleted = conn.execute(
+            "DELETE FROM agents WHERE id = ?1 AND is_default = 0",
+            params![id],
+        ).map_err(|e| format!("Agent delete: {}", e))?;
+        if deleted == 0 {
+            Err("Agenttia ei löydy tai se on oletusagentti".to_string())
+        } else {
+            Ok(())
+        }
+    }
+
     pub fn insert_pair_result(
         &self,
         node_id: u64,

network-poc/hub/src/main.rs

@@ -25,7 +25,7 @@ const ALLOWED_ORIGINS: &[&str] = &[
 ];
 
 // Sallitut viestityyypit clientilta
-const ALLOWED_MSG_TYPES: &[&str] = &["auth", "result", "pair_done", "llm_chunk", "llm_done", "llm_error", "download_progress", "user_text", "single_tokenize_done"];
+const ALLOWED_MSG_TYPES: &[&str] = &["auth", "result", "pair_done", "llm_chunk", "llm_done", "llm_error", "download_progress", "user_text", "single_tokenize_done", "status_update"];
 
 struct AppState {
     next_node_id: Mutex<u64>,
@@ -34,14 +34,18 @@ struct AppState {
     total_tasks: Mutex<u64>,
     stats_tx: broadcast::Sender<String>,
     node_channels: tokio::sync::RwLock<HashMap<u64, tokio::sync::mpsc::UnboundedSender<String>>>, // Kohdennettu reititys
-    pending_consensus: tokio::sync::RwLock<HashMap<String, Vec<serde_json::Value>>>, // Proof of Compute -konsensus
+    _pending_consensus: tokio::sync::RwLock<HashMap<String, Vec<serde_json::Value>>>, // Proof of Compute -konsensus
     feature_flags: tokio::sync::RwLock<HashMap<String, bool>>, // Tuntee TODO.md:n ruksit lennosta
     ip_connections: Mutex<HashMap<IpAddr, u32>>,
     node_ips: Mutex<HashMap<u64, IpAddr>>,
     node_tasks: Mutex<HashMap<u64, String>>,  // node_id → selected_task
+    node_types: Mutex<HashMap<u64, String>>,  // node_id → "native" | "browser"
+    node_paused: Mutex<std::collections::HashSet<u64>>, // node_id → onko tauolla
     node_busy: Mutex<std::collections::HashSet<u64>>,  // Solmut joilla on aktiivinen tehtävä
     pending_task_ids: Mutex<std::collections::HashSet<String>>,  // Hubin jakamat task_id:t (gamification-validointi)
+    pending_responses: Mutex<HashMap<String, tokio::sync::oneshot::Sender<serde_json::Value>>>,  // task_id → oneshot API-vastaukselle
     api_rate_limits: Mutex<HashMap<IpAddr, (std::time::Instant, u32)>>,  // IP → (ikkuna-alku, pyyntömäärä)
+    node_models: tokio::sync::RwLock<HashMap<u64, serde_json::Value>>, // node_id → ollama tags JSON
     db: db::NodeDb,
 }
 
@@ -79,6 +83,8 @@ tr:hover td { background:#1c2333; }
 .table-wrap { overflow-x:auto; max-height:70vh; overflow-y:auto; }
 .online { color:var(--green); }
 .offline { color:#8b949e; }
+.pause-btn { background:var(--panel); border:1px solid var(--border); color:var(--text); padding:4px 8px; border-radius:4px; cursor:pointer; font-size:12px; }
+.pause-btn:hover { border-color:var(--yellow); }
 </style>
 </head>
 <body>
@@ -90,6 +96,7 @@ tr:hover td { background:#1c2333; }
 <div class="tabs">
     <div class="tab active" onclick="showTab('sessions')">Sessiot</div>
     <div class="tab" onclick="showTab('pairs')">Tokenisointiparit</div>
+    <div class="tab" onclick="showTab('hardware')">Laitteisto & Mallit</div>
 </div>
 
 <div id="sessions" class="panel active">
@@ -98,12 +105,12 @@ tr:hover td { background:#1c2333; }
         <colgroup>
             <col style="width:35px"><col style="width:85px"><col style="width:95px"><col style="width:65px"><col style="width:110px"><col style="width:80px">
             <col style="width:65px"><col style="width:40px"><col style="width:70px"><col style="width:90px"><col style="width:60px">
-            <col style="width:65px"><col style="width:40px"><col style="width:130px"><col style="width:60px">
+            <col style="width:65px"><col style="width:40px"><col style="width:130px"><col style="width:60px"><col style="width:80px">
         </colgroup>
         <thead><tr>
             <th>ID</th><th>Tila</th><th>Tehtävä</th><th>Tyyppi</th><th>IP</th><th>Alusta</th>
             <th>OS</th><th>CPU</th><th>RAM</th><th>GPU</th><th>VRAM</th>
-            <th>WebGPU</th><th>Teht.</th><th>Yhdistetty</th><th>Kesto</th>
+            <th>WebGPU</th><th>Teht.</th><th>Yhdistetty</th><th>Kesto</th><th>Toiminnot</th>
         </tr></thead><tbody id="sessions-body"></tbody></table>
     </div>
 </div>
@@ -117,6 +124,19 @@ tr:hover td { background:#1c2333; }
     </div>
 </div>
 
+<div id="hardware" class="panel">
+    <div class="stats-grid" id="hardware-stats"></div>
+    <h2 style="margin-top: 10px; margin-bottom: 10px; color: var(--accent); font-size: 16px;">Käytettävissä olevat paikalliset kielimallit</h2>
+    <div class="table-wrap">
+        <table>
+            <thead><tr>
+                <th>Nimi</th><th>Koko</th><th>Parametrit</th>
+            </tr></thead>
+            <tbody id="models-body"></tbody>
+        </table>
+    </div>
+</div>
+
 <script>
 function showTab(name) {
     document.querySelectorAll('.panel').forEach(p => p.classList.remove('active'));
@@ -148,12 +168,16 @@ function duration(start, end) {
 }
 
 async function load() {
-    const [statsRes, sessionsRes, pairsRes] = await Promise.all([
+    const [statsRes, sessionsRes, pairsRes, hwRes, modelsRes] = await Promise.all([
-        fetch('/api/stats'), fetch('/api/sessions'), fetch('/api/pairs')
+        fetch('/api/stats'), fetch('/api/sessions'), fetch('/api/pairs'),
+        fetch('/api/v1/hardware').catch(() => ({json: async()=>({gpu_name:'', vram_mb:0, ram_mb:0})})),
+        fetch('/api/v1/ollama/tags').catch(() => ({json: async()=>({models:[]})}))
     ]);
     const stats = await statsRes.json();
     const sessions = await sessionsRes.json();
     const pairs = await pairsRes.json();
+    const hw = await hwRes.json().catch(() => ({gpu_name:'', vram_mb:0, ram_mb:0}));
+    const modelsData = await modelsRes.json().catch(() => ({models:[]}));
 
     // Versio
     if (stats.version) document.getElementById('admin-version').textContent = 'v' + stats.version;
@@ -189,9 +213,17 @@ async function load() {
     document.getElementById('sessions-body').innerHTML = sessions.map(s => {
         const online = !s.disconnected_at;
         const isViewer = s.selected_task === 'viewer';
-        const status = online
+        let status;
-            ? (isViewer ? '<span style="color:#d29922">CONNECTED</span>' : '<span class="online">ACTIVE</span>')
+        if (!online) {
-            : '<span class="offline">offline</span>';
+            status = '<span class="offline">offline</span>';
+        } else if (isViewer) {
+            status = '<span style="color:#d29922">CONNECTED</span>';
+        } else if (s.is_paused) {
+            status = '<span style="color:#8b949e">PAUSED</span>';
+        } else {
+            status = '<span class="online">ACTIVE</span>';
+        }
+        
         const typeBadge = s.node_type === 'native' ? badge('native','blue') : badge('browser','yellow');
         const taskColor = isViewer ? 'yellow' : s.selected_task === 'tokenize' ? 'green' : 'blue';
         const taskBadge = badge(taskNames[s.selected_task] || s.selected_task || '?', taskColor);
@@ -204,11 +236,16 @@ async function load() {
         const os = s.os || '-';
         const time = s.connected_at ? new Date(s.connected_at).toLocaleString('fi-FI') : '';
         const dur = duration(s.connected_at, s.disconnected_at);
+        const actionBtn = online && !isViewer 
+            ? `<button class="pause-btn" onclick="togglePause(${s.node_id}, ${s.is_paused})">${s.is_paused ? '▶ Työhön' : '⏸ Tauolle'}</button>` 
+            : '';
+            
         return `<tr>
             <td>${s.node_id}</td><td>${status}</td><td>${taskBadge}</td><td>${typeBadge}</td><td>${s.ip}</td>
             <td>${plat}</td><td>${os}</td><td>${cores}</td><td>${ram}</td>
             <td>${gpu}</td><td>${vram}</td><td>${gpuBadge}</td>
             <td>${s.tasks_completed}</td><td>${time}</td><td>${dur}</td>
+            <td>${actionBtn}</td>
         </tr>`;
     }).join('');
 
@@ -228,6 +265,35 @@ async function load() {
             <td>${p.duration_ms||0}ms</td>
         </tr>`;
     }).join('');
+
+    // Hardware
+    document.getElementById('hardware-stats').innerHTML = [
+        {v: hw.gpu_name || '-', l: 'Paikallinen GPU tila'},
+        {v: hw.vram_mb ? hw.vram_mb + ' MB' : '-', l: 'GPU Muisti (VRAM)'},
+        {v: hw.ram_mb ? hw.ram_mb + ' MB' : '-', l: 'RAM'},
+    ].map(s => `<div class="stat-card"><div class="val">${s.v}</div><div class="label">${s.l}</div></div>`).join('');
+
+    // Models
+    document.getElementById('models-body').innerHTML = (modelsData.models || []).map(m => {
+        const sizeGb = (m.size / (1024*1024*1024)).toFixed(2) + ' GB';
+        const params = m.details?.parameter_size || '-';
+        return `<tr>
+            <td><strong>${m.name}</strong></td>
+            <td>${sizeGb}</td>
+            <td>${params}</td>
+        </tr>`;
+    }).join('');
+}
+
+async function togglePause(nodeId, isPaused) {
+    try {
+        await fetch('/api/v1/control/' + nodeId, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action: isPaused ? 'resume' : 'pause' })
+        });
+        load(); // virkistetään
+    } catch(e) { console.error(e); }
 }
 
 load();
@@ -255,14 +321,18 @@ async fn main() {
         total_tasks: Mutex::new(0),
         stats_tx: stats_tx.clone(),
         node_channels: tokio::sync::RwLock::new(HashMap::new()),
-        pending_consensus: tokio::sync::RwLock::new(HashMap::new()),
+        _pending_consensus: tokio::sync::RwLock::new(HashMap::new()),
         feature_flags: tokio::sync::RwLock::new(HashMap::new()),
         ip_connections: Mutex::new(HashMap::new()),
         node_ips: Mutex::new(HashMap::new()),
         node_tasks: Mutex::new(HashMap::new()),
+        node_types: Mutex::new(HashMap::new()),
+        node_paused: Mutex::new(std::collections::HashSet::new()),
         node_busy: Mutex::new(std::collections::HashSet::new()),
         pending_task_ids: Mutex::new(std::collections::HashSet::new()),
+        pending_responses: Mutex::new(HashMap::new()),
         api_rate_limits: Mutex::new(HashMap::new()),
+        node_models: tokio::sync::RwLock::new(HashMap::new()),
         db: db::NodeDb::new(&std::env::var("DATABASE_PATH").unwrap_or_else(|_| "nodes.db".to_string())),
     });
 
@@ -328,15 +398,6 @@ async fn main() {
             let idx = (rng_state as usize) % pairs.len();
             let (en, fi) = pairs[idx];
 
-            // Tokenisointiparit
-            let pair_msg = serde_json::json!({
-                "type": "pair_task",
-                "en": en,
-                "fi": fi,
-            });
-            let _ = state_for_task.stats_tx.send(pair_msg.to_string());
-
-            // LLM-promptit
             let llm_prompts = vec![
                 "Tell me a short joke.",
                 "What is WebGPU in one sentence?",
@@ -346,33 +407,39 @@ async fn main() {
             ];
             let llm_idx = (rng_state as usize / 7) % llm_prompts.len();
 
-            // SmolLM-prompt
+            // Smart Routing: Lähetetään vain niille, jotka valittuna ja idle
-            let smollm_msg = serde_json::json!({
+            let mut sends = Vec::new();
-                "type": "llm_prompt",
+            {
-                "prompt": llm_prompts[llm_idx],
+                let channels = state_for_task.node_channels.read().await;
-                "model": "smollm-135m",
+                let tasks = state_for_task.node_tasks.lock().unwrap();
-            });
+                let mut busy = state_for_task.node_busy.lock().unwrap();
-            let _ = state_for_task.stats_tx.send(smollm_msg.to_string());
 
-            // Qwen-prompt (sama prompti, eri malli-tagi)
+                for (node_id, task) in tasks.iter() {
-            let qwen_msg = serde_json::json!({
+                    if !busy.contains(node_id) {
-                "type": "llm_prompt",
+                        // Vapaa node -> lähetetään oikea tehtävä
-                "prompt": llm_prompts[llm_idx],
+                        let msg = match task.as_str() {
-                "model": "qwen-05b",
+                            "tokenize" => Some(serde_json::json!({ "type": "pair_task", "en": en, "fi": fi })),
-            });
+                            "smollm-135m" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "smollm-135m" })),
-            let _ = state_for_task.stats_tx.send(qwen_msg.to_string());
+                            "qwen-05b" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "qwen-05b" })),
+                            "phi3-mini" => Some(serde_json::json!({ "type": "llm_prompt", "prompt": llm_prompts[llm_idx], "model": "phi3-mini" })),
+                            _ => None, // Coder ja viewer ei saa auto-tehtäviä
+                        };
 
-            // Phi-3 prompt
+                        if let Some(payload) = msg {
-            let phi3_msg = serde_json::json!({
+                            if let Some(ch) = channels.get(node_id) {
-                "type": "llm_prompt",
+                                sends.push((ch.clone(), payload.to_string()));
-                "prompt": llm_prompts[llm_idx],
+                                busy.insert(*node_id);
-                "model": "phi3-mini",
+                            }
-            });
+                        }
-            let _ = state_for_task.stats_tx.send(phi3_msg.to_string());
+                    }
+                }
+            }
 
-            // Coder ei saa automaattisia tehtäviä — vain käyttäjän user_text
+            for (ch, msg_str) in sends {
+                let _ = ch.send(msg_str);
+            }
 
-            tracing::debug!("Tehtävät lähetetty: pair + smollm + qwen + phi3");
+            // tracing::debug!("Tehtävät lähetetty reititetysti idle-nodeille");
         }
     });
 
@@ -382,9 +449,15 @@ async fn main() {
         .route("/api/pairs", get(api_pairs))
         .route("/api/stats", get(api_stats))
         .route("/api/v1/chat/completions", axum::routing::post(api_chat_completions))
+        .route("/api/v1/control/:id", axum::routing::post(api_control_node))
+        .route("/api/v1/model", axum::routing::post(api_change_model))
+        .route("/api/v1/hardware", get(api_hardware))
+        .route("/api/v1/ollama/tags", get(api_ollama_tags))
+        .route("/api/v1/agents", get(api_get_agents).post(api_upsert_agent))
+        .route("/api/v1/agents/:id", axum::routing::delete(api_delete_agent))
         .route("/admin", get(admin_page))
         .nest_service("/", {
-            let static_dir = std::env::var("STATIC_DIR").unwrap_or_else(|_| "../static".to_string());
+            let static_dir = std::env::var("STATIC_DIR").unwrap_or_else(|_| "../frontend/dist".to_string());
             ServeDir::new(&static_dir).fallback(ServeFile::new(format!("{}/index.html", static_dir)))
         })
         .with_state(state);
@@ -396,6 +469,26 @@ async fn main() {
     axum::serve(listener, app.into_make_service_with_connect_info::<SocketAddr>()).await.unwrap();
 }
 
+async fn api_control_node(
+    headers: axum::http::HeaderMap,
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::extract::Path(id): axum::extract::Path<u64>,
+    axum::Json(payload): axum::Json<serde_json::Value>,
+) -> axum::response::Response {
+    if !check_admin_auth(&headers) { return admin_unauthorized(); }
+    let action = payload.get("action").and_then(|v| v.as_str()).unwrap_or("");
+    if action == "pause" || action == "resume" {
+        let msg = serde_json::json!({ "type": "control", "action": action });
+        let channels = state.node_channels.read().await;
+        if let Some(tx) = channels.get(&id) {
+            let _ = tx.send(msg.to_string());
+            tracing::info!("Lähetetty control: {} solmulle {}", action, id);
+            return axum::Json(serde_json::json!({"status": "ok"})).into_response();
+        }
+    }
+    (axum::http::StatusCode::BAD_REQUEST, "Invalid action or node offline").into_response()
+}
+
 async fn api_sessions(
     headers: axum::http::HeaderMap,
     axum::extract::State(state): axum::extract::State<Arc<AppState>>,
@@ -457,6 +550,34 @@ fn admin_unauthorized() -> axum::response::Response {
         .unwrap()
 }
 
+// ── Agents API ──
+
+async fn api_get_agents(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+) -> axum::response::Response {
+    axum::Json(state.db.get_agents()).into_response()
+}
+
+async fn api_upsert_agent(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::Json(payload): axum::Json<serde_json::Value>,
+) -> axum::response::Response {
+    match state.db.upsert_agent(&payload) {
+        Ok(()) => axum::Json(serde_json::json!({"ok": true})).into_response(),
+        Err(e) => (axum::http::StatusCode::BAD_REQUEST, e).into_response(),
+    }
+}
+
+async fn api_delete_agent(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::extract::Path(id): axum::extract::Path<String>,
+) -> axum::response::Response {
+    match state.db.delete_agent(&id) {
+        Ok(()) => axum::Json(serde_json::json!({"ok": true})).into_response(),
+        Err(e) => (axum::http::StatusCode::BAD_REQUEST, e).into_response(),
+    }
+}
+
 async fn admin_page(headers: axum::http::HeaderMap) -> axum::response::Response {
     if !check_admin_auth(&headers) { return admin_unauthorized(); }
     axum::response::Html(ADMIN_HTML).into_response()
@@ -470,7 +591,12 @@ async fn ws_handler(
 ) -> impl IntoResponse {
     // Origin-tarkistus — estää cross-site WebSocket hijackingin
     if let Some(origin) = headers.get("origin").and_then(|v| v.to_str().ok()) {
-        if !ALLOWED_ORIGINS.iter().any(|&allowed| origin == allowed) {
+        let is_allowed = ALLOWED_ORIGINS.iter().any(|&allowed| origin == allowed)
+            || origin.starts_with("http://192.168.")
+            || origin.starts_with("http://10.")
+            || origin.starts_with("http://172."); // LAN-avaruudet
+            
+        if !is_allowed {
             tracing::warn!("Estetty yhteys väärällä originilla: {}", origin);
             return (
                 axum::http::StatusCode::FORBIDDEN,
@@ -486,16 +612,19 @@ async fn ws_handler(
         .and_then(|s| s.trim().parse::<IpAddr>().ok())
         .unwrap_or_else(|| addr.ip());
 
-    // Max yhteyttä per IP: jokainen selain tarvitsee 2 (UI + coder-node)
+    // Max yhteyttä per IP (ei rajoiteta localhost/127.0.0.1)
     {
-        let conns = state.ip_connections.lock().unwrap();
+        let is_local = ip.is_loopback();
-        let count = conns.get(&ip).copied().unwrap_or(0);
+        if !is_local {
-        if count >= 10 {
+            let conns = state.ip_connections.lock().unwrap();
-            tracing::warn!("IP {} ylitti yhteysrajan ({}/10) — estetty", ip, count);
+            let count = conns.get(&ip).copied().unwrap_or(0);
-            return (
+            if count >= 20 {
-                axum::http::StatusCode::TOO_MANY_REQUESTS,
+                tracing::warn!("IP {} ylitti yhteysrajan ({}/20) — estetty", ip, count);
-                "Max 10 yhteyttä per IP",
+                return (
-            ).into_response();
+                    axum::http::StatusCode::TOO_MANY_REQUESTS,
+                    "Max 20 yhteyttä per IP",
+                ).into_response();
+            }
         }
     }
 
@@ -523,6 +652,17 @@ async fn broadcast_stats(state: &Arc<AppState>) {
         "tasks": completed
     });
     let _ = state.stats_tx.send(stats_msg.to_string());
+
+    // Uutta: Laitetaan sama tieto myös kaikille yhdistyneille solmuille (viesti Hubilta Solmuille)
+    let node_status = serde_json::json!({
+        "type": "network_status",
+        "active_nodes": total_nodes,
+        "tasks": completed
+    });
+    let msg_str = node_status.to_string();
+    for tx in state.node_channels.read().await.values() {
+        let _ = tx.send(msg_str.clone());
+    }
 }
 
 /// Validoi client-viesti: pakollinen "type"-kenttä, sallittu tyyppi, validi JSON
@@ -656,6 +796,18 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                 let allocated = json.get("allocated_gb").and_then(|v| v.as_u64()).unwrap_or(4) as u32;
                 let node_type = json.get("node_type").and_then(|v| v.as_str()).unwrap_or("browser");
 
+                // API-avain vaaditaan natiivisolmuilta (ei selaimilta)
+                if node_type == "native" {
+                    let required_key = std::env::var("NODE_API_KEY").unwrap_or_default();
+                    if !required_key.is_empty() {
+                        let provided_key = json.get("api_key").and_then(|v| v.as_str()).unwrap_or("");
+                        if provided_key != required_key {
+                            tracing::warn!("Solmu {} ({}) hylätty: virheellinen API-avain", node_id, ip);
+                            break; // Suljetaan WebSocket
+                        }
+                    }
+                }
+
                 {
                     let mut map = state.nodes_vram.lock().unwrap();
                     map.insert(node_id, allocated);
@@ -677,6 +829,10 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                     state.db.insert_session(node_id, &ip.to_string(), node_type, &json);
                 }
                 state.node_tasks.lock().unwrap().insert(node_id, selected_task);
+                state.node_types.lock().unwrap().insert(node_id, node_type.to_string());
+                // Uudelleen-kirjautuessa nollataan tauko
+                state.node_paused.lock().unwrap().remove(&node_id);
+                state.db.update_session_status(node_id, false);
 
                 if node_type == "native" {
                     let sys = json.get("system");
@@ -690,6 +846,12 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                         node_id, ip, hostname, os, cores, ram, allocated
                     );
 
+                    // Tallennetaan välitetyt mallit muistiin
+                    if let Some(models) = json.get("models") {
+                        let mut nm = state.node_models.write().await;
+                        nm.insert(node_id, models.clone());
+                    }
+
                     if let Some(gpus) = json.get("gpus").and_then(|v| v.as_array()) {
                         for gpu in gpus {
                             tracing::info!(
@@ -727,6 +889,18 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
             });
             let _ = state.stats_tx.send(join_msg.to_string());
 
+        } else if msg_type == "status_update" {
+            let status = json.get("status").and_then(|v| v.as_str()).unwrap_or("active");
+            if status == "paused" {
+                state.node_paused.lock().unwrap().insert(node_id);
+                state.db.update_session_status(node_id, true);
+                tracing::info!("Solmu {} ({}) asettui tauolle.", node_id, ip);
+            } else {
+                state.node_paused.lock().unwrap().remove(&node_id);
+                state.db.update_session_status(node_id, false);
+                tracing::info!("Solmu {} ({}) on taas aktiivinen.", node_id, ip);
+            }
+            broadcast_stats(&state).await;
         } else if msg_type == "result" {
             tracing::info!("Solmu {} sai tuloksen: {}", node_id, text);
             {
@@ -735,6 +909,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
             }
             broadcast_stats(&state).await;
         } else if msg_type == "pair_done" {
+            state.node_busy.lock().unwrap().remove(&node_id);
             {
                 let mut json = json; // Siirretään omistajuus muokkausta varten
                 if let Some(obj) = json.as_object_mut() {
@@ -821,11 +996,18 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
         } else if msg_type == "llm_done" {
             // Vapautetaan solmu ja tarkistetaan task_id:n aitous
             state.node_busy.lock().unwrap().remove(&node_id);
-            let valid_task = if let Some(tid) = json.get("task_id").and_then(|v| v.as_str()) {
+            let task_id = json.get("task_id").and_then(|v| v.as_str()).map(|s| s.to_string());
-                state.pending_task_ids.lock().unwrap().remove(tid)
+            let valid_task = if let Some(ref tid) = task_id {
+                state.pending_task_ids.lock().unwrap().remove(tid.as_str())
             } else {
                 false
             };
+
+            // Jos API-pyyntö odottaa tätä vastausta, reititetään suoraan oneshot-kanavaan
+            let api_sender = task_id.as_ref().and_then(|tid| {
+                state.pending_responses.lock().unwrap().remove(tid)
+            });
+
             {
                 let mut json = json;
                 if let Some(obj) = json.as_object_mut() {
@@ -845,6 +1027,12 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                     state.db.increment_tasks(node_id);
                     obj.insert("node_id".to_string(), serde_json::json!(node_id));
                 }
+
+                if let Some(sender) = api_sender {
+                    // API-pyyntö: reititetään vastaus suoraan odottajalle
+                    let _ = sender.send(json.clone());
+                }
+                // UI-broadcast jatkuu normaalisti
                 let _ = state.stats_tx.send(json.to_string());
 
                 let active_incentives = state.feature_flags.read().await.get("Insentiivit").copied().unwrap_or(false);
@@ -854,7 +1042,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                 {
                     let mut task_count = state.total_tasks.lock().unwrap();
                     *task_count += 1;
-                    
+
                     if active_incentives && valid_task {
                         let mut tokens = state.nodes_tokens.lock().unwrap();
                         let balance = tokens.entry(node_id).or_insert(0);
@@ -862,7 +1050,7 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                         current_balance = *balance;
                     }
                 }
-                
+
                 if active_incentives && ui_sync {
                     if let Some(tx) = state.node_channels.read().await.get(&node_id) {
                          let msg = serde_json::json!({
@@ -872,45 +1060,50 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
                          let _ = tx.send(msg.to_string());
                     }
                 }
-                
+
                 broadcast_stats(&state).await;
             }
         } else if msg_type == "llm_error" {
             state.node_busy.lock().unwrap().remove(&node_id);
-            if let Some(tid) = json.get("task_id").and_then(|v| v.as_str()) {
+            let task_id = json.get("task_id").and_then(|v| v.as_str()).map(|s| s.to_string());
-                state.pending_task_ids.lock().unwrap().remove(tid);
+            if let Some(ref tid) = task_id {
+                state.pending_task_ids.lock().unwrap().remove(tid.as_str());
             }
+            // Jos API-pyyntö odottaa, reititetään virhe oneshot-kanavaan
+            let api_sender = task_id.as_ref().and_then(|tid| {
+                state.pending_responses.lock().unwrap().remove(tid)
+            });
             {
                 let mut json = json;
                 if let Some(obj) = json.as_object_mut() {
                     obj.insert("node_id".to_string(), serde_json::json!(node_id));
                 }
+                if let Some(sender) = api_sender {
+                    let _ = sender.send(json.clone());
+                }
                 let _ = state.stats_tx.send(json.to_string());
             }
         } else if msg_type == "user_text" {
-            // Käyttäjän lähettämä teksti — broadcastataan pair_taskina ja llm_promptina
+            // Käyttäjän lähettämä teksti — kohdennettu reititys lähettäjäsolmulle
             let text = json.get("text").and_then(|v| v.as_str()).unwrap_or("").to_string();
             let task_type = json.get("task_type").and_then(|v| v.as_str()).unwrap_or("tokenize");
             if !text.is_empty() {
                 let preview: String = text.chars().take(80).collect();
                 tracing::info!("Solmu {} lähetti oman tekstin ({}): \"{}\"", node_id, task_type, preview);
-                match task_type {
+                let msg = match task_type {
-                    "tokenize" => {
+                    "tokenize" => serde_json::json!({
-                        let msg = serde_json::json!({
+                        "type": "single_tokenize",
-                            "type": "single_tokenize",
+                        "text": text,
-                            "text": text,
+                    }),
-                        });
+                    _ => serde_json::json!({
-                        let _ = state.stats_tx.send(msg.to_string());
+                        "type": "llm_prompt",
-                    }
+                        "prompt": text,
-                    _ => {
+                        "model": task_type,
-                        // LLM-prompti: lähetetään VAIN valitulle mallille, ei kaikille (välttää turhaa ruuhkaa ja busy-tiloja)
+                    }),
-                        let prompt = serde_json::json!({
+                };
-                            "type": "llm_prompt",
+                // Lähetetään takaisin lähettäjäsolmulle (käyttäjä haluaa oman tekstinsä tuloksen)
-                            "prompt": text,
+                if let Some(tx) = state.node_channels.read().await.get(&node_id) {
-                            "model": task_type,
+                    let _ = tx.send(msg.to_string());
-                        });
-                        let _ = state.stats_tx.send(prompt.to_string());
-                    }
                 }
             }
         }
@@ -934,6 +1127,9 @@ async fn handle_socket(socket: WebSocket, state: Arc<AppState>, ip: IpAddr) {
         ips.remove(&node_id);
         vram.remove(&node_id);
     }
+    state.node_types.lock().unwrap().remove(&node_id);
+    state.node_paused.lock().unwrap().remove(&node_id);
+    state.node_models.write().await.remove(&node_id);
     tracing::info!("Solmu {} ({}) poistui verkosta.", node_id, ip);
     broadcast_stats(&state).await;
     sender_task.abort();
@@ -943,6 +1139,8 @@ struct ChatCompletionRequest {
     model: String,
     prompt: String,
     task_id: String,
+    #[serde(default)]
+    max_tokens: Option<u64>,
 }
 
 #[derive(serde::Serialize)]
@@ -952,6 +1150,86 @@ struct ChatCompletionResponse {
     tokens_generated: u64,
 }
 
+async fn api_ollama_tags(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+) -> axum::response::Response {
+    // Haetaan natiivisolmun tila muistista — priorisoidaan aito verkko-solmu
+    let node_models = state.node_models.read().await;
+    if let Some((_, models_json)) = node_models.iter().next() {
+        return axum::Json(models_json.clone()).into_response();
+    }
+
+    // Fallback: Haetaan lokaalista infra-Ollamasta ohjaimesta käsin (esim dev ympäristö)
+    let ollama_url = std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://ollama:11434".to_string());
+    match reqwest::get(format!("{}/api/tags", ollama_url)).await {
+        Ok(resp) => {
+            if let Ok(body) = resp.json::<serde_json::Value>().await {
+                axum::Json(body).into_response()
+            } else {
+                axum::Json(serde_json::json!({ "models": [] })).into_response()
+            }
+        }
+        Err(_) => axum::Json(serde_json::json!({ "models": [] })).into_response(),
+    }
+}
+
+async fn api_hardware(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+) -> axum::response::Response {
+    // Etsitään natiivisolmun GPU-tiedot sessiosta
+    let sessions = state.db.get_sessions(50);
+    let native = sessions.iter().find(|s| {
+        s.get("node_type").and_then(|v| v.as_str()) == Some("native")
+    });
+
+    let (mut vram_mb, mut gpu_name, ram_mb) = if let Some(s) = native {
+        // Tieto on tietokannassa litteänä
+        let vram = s.get("vram_total_mb").and_then(|v| v.as_u64()).unwrap_or(0);
+        let name = s.get("gpu_name").and_then(|v| v.as_str()).unwrap_or("").to_string();
+        let ram = s.get("ram_mb").and_then(|v| v.as_u64()).unwrap_or(0);
+        (vram, name, ram)
+    } else {
+        (0, String::new(), 0)
+    };
+
+    // Fallback: kysytään Ollamalta onko malleja ladattu (= Ollama on käynnissä)
+    if vram_mb == 0 {
+        let ollama_url = std::env::var("OLLAMA_URL").unwrap_or_else(|_| "http://ollama:11434".to_string());
+        if let Ok(resp) = reqwest::get(format!("{}/api/tags", ollama_url)).await {
+            if let Ok(body) = resp.json::<serde_json::Value>().await {
+                let models = body["models"].as_array().map(|a| a.len()).unwrap_or(0);
+                if models > 0 {
+                    gpu_name = "Ollama (GPU/CPU)".to_string();
+                    // Natiivisolmun RAM fallbackina
+                    vram_mb = if ram_mb > 0 { ram_mb } else { 0 };
+                }
+            }
+        }
+    }
+
+    if gpu_name.is_empty() { gpu_name = "ei natiivisolmua".to_string(); }
+
+    axum::Json(serde_json::json!({
+        "gpu_name": gpu_name,
+        "vram_mb": vram_mb,
+        "ram_mb": ram_mb,
+    })).into_response()
+}
+
+async fn api_change_model(
+    axum::extract::State(state): axum::extract::State<Arc<AppState>>,
+    axum::Json(payload): axum::Json<serde_json::Value>,
+) -> axum::response::Response {
+    let model = payload.get("model").and_then(|v| v.as_str()).unwrap_or("");
+    if model.is_empty() {
+        return (axum::http::StatusCode::BAD_REQUEST, "model puuttuu").into_response();
+    }
+    tracing::info!("Mallin vaihto: {}", model);
+    let msg = serde_json::json!({ "type": "change_model", "model": model });
+    let _ = state.stats_tx.send(msg.to_string());
+    axum::Json(serde_json::json!({ "status": "ok", "model": model })).into_response()
+}
+
 async fn api_chat_completions(
     axum::extract::State(state): axum::extract::State<Arc<AppState>>,
     ConnectInfo(addr): ConnectInfo<SocketAddr>,
@@ -966,108 +1244,77 @@ async fn api_chat_completions(
             *entry = (now, 1); // Uusi ikkuna
         } else {
             entry.1 += 1;
-            if entry.1 > 10 {
+            if entry.1 > 30 {
                 return (axum::http::StatusCode::TOO_MANY_REQUESTS, "Liian monta pyyntöä — yritä minuutin kuluttua").into_response();
             }
         }
     }
 
-    // Etsitään vapaa tai varattu solmu, joka vastaa pyydettyä mallia
+    // Etsitään vapaa solmu — priorisoidaan natiivisolmut (GPU) selaimen edelle
-    let (target_node_free, target_node_any, total_matching) = {
+    let (target_node, _total_matching) = {
         let tasks = state.node_tasks.lock().unwrap();
-        let busy = state.node_busy.lock().unwrap();
+        let _busy = state.node_busy.lock().unwrap();
-        let matching: Vec<u64> = tasks.iter().filter(|(_, task)| {
+        let node_types = state.node_types.lock().unwrap();
-            if payload.model == "qwen-coder" {
+        let paused = state.node_paused.lock().unwrap();
-                task.starts_with("qwen-coder")
+        let matching: Vec<u64> = tasks.iter().filter(|(k, task)| {
+            if paused.contains(k) { return false; } // Ei sallita tauotettuja
+            // Eksakti match tai qwen-perheen yhteensopivuus (selain: qwen-coder-05b, natiivi: qwen2.5-coder:7b)
+            let req_model = payload.model.to_lowercase();
+            let node_task = task.to_lowercase();
+            if req_model.starts_with("qwen") {
+                node_task.starts_with("qwen")
+            } else if req_model.starts_with("phi") {
+                node_task.starts_with("phi")
             } else {
                 **task == payload.model
             }
         }).map(|(k, _)| *k).collect();
-        let free = matching.iter().find(|id| !busy.contains(id)).copied();
+        // Etsitään mikä tahansa matchaava solmu (natiivi priorisoidaan)
-        let any = matching.first().copied();
+        let native = matching.iter().find(|id| {
-        (free, any, matching.len())
+            node_types.get(id).map(|t| t == "native").unwrap_or(false)
+        }).copied();
+        let any = native.or_else(|| matching.first().copied());
+        (any, matching.len())
     };
 
-    // Broadcastataan reititystila UI:lle
     let task_id = payload.task_id.clone();
 
-    if target_node_any.is_none() {
+    let target_node_id = match target_node {
-        // Ei yhtään solmua tälle mallille
+        Some(id) => id,
-        return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Ei solmua tälle mallille (käynnistä malli selaimessa)").into_response();
+        None => {
-    }
+            return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Ei solmua tälle mallille (käynnistä malli selaimessa)").into_response();
+        }
+    };
 
-    let target_node_id;
+    // Reititystila UI:lle
-    if let Some(free_id) = target_node_free {
+    {
-        // Vapaa solmu löytyi — reititetään suoraan
-        target_node_id = free_id;
-        let node_type = if state.node_tasks.lock().unwrap().get(&free_id).map(|t| t.contains("native")).unwrap_or(false) { "natiivi" } else { "selain" };
         let routing_msg = serde_json::json!({
             "type": "task_routed",
             "task_id": task_id,
-            "node_id": free_id,
+            "node_id": target_node_id,
-            "node_type": node_type,
             "status": "routed",
-            "message": format!("Reititetty solmulle #{}", free_id),
+            "message": format!("Reititetty solmulle #{}", target_node_id),
         });
         let _ = state.stats_tx.send(routing_msg.to_string());
-    } else {
+    }
-        // Kaikki solmut varattuja — odotetaan vapautumista (max 30s)
-        let queue_msg = serde_json::json!({
-            "type": "task_routed",
-            "task_id": task_id,
-            "status": "queued",
-            "message": format!("Kaikki {} solmua varattuja — odotetaan vapautumista...", total_matching),
-        });
-        let _ = state.stats_tx.send(queue_msg.to_string());
-
-        // Pollaa busy-tilaa 500ms välein, max 30s
-        let mut waited = 0u32;
-        loop {
-            tokio::time::sleep(std::time::Duration::from_millis(500)).await;
-            waited += 500;
-            let free = {
-                let tasks = state.node_tasks.lock().unwrap();
-                let busy = state.node_busy.lock().unwrap();
-                tasks.iter().find(|(node_id, task)| {
-                    let model_match = if payload.model == "qwen-coder" {
-                        *task == "qwen-coder-05b" || *task == "qwen-coder"
-                    } else {
-                        **task == payload.model
-                    };
-                    model_match && !busy.contains(node_id)
-                }).map(|(k, _)| *k)
-            };
-            if let Some(id) = free {
-                target_node_id = id;
-                let routing_msg = serde_json::json!({
-                    "type": "task_routed",
-                    "task_id": task_id,
-                    "node_id": id,
-                    "status": "routed",
-                    "message": format!("Solmu #{} vapautui — reititetään ({:.1}s jonossa)", id, waited as f64 / 1000.0),
-                });
-                let _ = state.stats_tx.send(routing_msg.to_string());
-                break;
-            }
-            if waited >= 30000 {
-                return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Aikakatkaisu: kaikki solmut varattuja 30s ajan").into_response();
-            }
-        }
-    };
 
     // Merkitään solmu varatuksi ja task_id jaetuksi
     state.node_busy.lock().unwrap().insert(target_node_id);
     state.pending_task_ids.lock().unwrap().insert(payload.task_id.clone());
 
-    let msg = serde_json::json!({
+    let mut msg = serde_json::json!({
         "type": "llm_prompt",
         "prompt": payload.prompt,
         "model": payload.model,
         "task_id": payload.task_id,
     });
+    if let Some(mt) = payload.max_tokens {
+        msg.as_object_mut().unwrap().insert("max_tokens".to_string(), serde_json::json!(mt));
+    }
 
-    // Odotuskanava valmiiksi (solmu palauttaa tuloksen stats_tx kautta)
+    // Oneshot-kanava: solmu palauttaa tuloksen suoraan tälle pyynnölle
-    let mut rx = state.stats_tx.subscribe();
+    let (resp_tx, resp_rx) = tokio::sync::oneshot::channel::<serde_json::Value>();
+    state.pending_responses.lock().unwrap().insert(payload.task_id.clone(), resp_tx);
 
     // Kohdennettu reititys: lähetetään AI-tehtävä suoraan VAIN valitulle solmulle
     {
@@ -1076,48 +1323,34 @@ async fn api_chat_completions(
             let _ = tx.send(msg.to_string());
             tracing::info!("Reititettiin API-pyyntö solmulle {} (Malli: {})", target_node_id, payload.model);
         } else {
+             state.pending_responses.lock().unwrap().remove(&payload.task_id);
              return (axum::http::StatusCode::SERVICE_UNAVAILABLE, "Verkkovirhe: solmun yhteys katkesi reitityksen aikana").into_response();
         }
     }
 
-    let timeout = tokio::time::timeout(std::time::Duration::from_secs(600), async move {
+    let timeout = tokio::time::timeout(std::time::Duration::from_secs(600), resp_rx).await;
-        loop {
-            let msg_str = match rx.recv().await {
-                Ok(msg) => msg,
-                Err(broadcast::error::RecvError::Lagged(n)) => {
-                    tracing::debug!("API-kanava lagged {} viestiä", n);
-                    continue;
-                }
-                Err(_) => return Ok(None), // Kanava suljettu
-            };
-            if let Ok(v) = serde_json::from_str::<serde_json::Value>(&msg_str) {
-                if v["type"].as_str() == Some("llm_done") {
-                    if let Some(tid) = v["task_id"].as_str() {
-                        if tid == payload.task_id {
-                            return Ok(Some(ChatCompletionResponse {
-                                response: v["response"].as_str().unwrap_or("").to_string(),
-                                model: v["model"].as_str().unwrap_or("").to_string(),
-                                tokens_generated: v["tokens_generated"].as_u64().unwrap_or(0),
-                            }));
-                        }
-                    }
-                } else if v["type"].as_str() == Some("llm_error") {
-                    if let Some(tid) = v["task_id"].as_str() {
-                        if tid == payload.task_id {
-                            return Err(v["error"].as_str().unwrap_or("Määrittelemätön virhe solmussa").to_string());
-                        }
-                    }
-                }
-            }
-        }
-        #[allow(unreachable_code)]
-        Ok(None)
-    }).await;
 
     match timeout {
-        Ok(Ok(Some(res))) => axum::Json(res).into_response(),
+        Ok(Ok(v)) => {
-        Ok(Ok(None)) => (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Verkkovirhe: yhteys katkesi").into_response(),
+            if v["type"].as_str() == Some("llm_error") {
-        Ok(Err(err)) => (axum::http::StatusCode::CONFLICT, err).into_response(),
+                let err = v["error"].as_str().unwrap_or("Määrittelemätön virhe solmussa").to_string();
-        Err(_) => (axum::http::StatusCode::GATEWAY_TIMEOUT, "Aikakatkaisu: solmu ei saanut tehtävää ajoissa valmiiksi").into_response(),
+                (axum::http::StatusCode::CONFLICT, err).into_response()
+            } else {
+                axum::Json(ChatCompletionResponse {
+                    response: v["response"].as_str().unwrap_or("").to_string(),
+                    model: v["model"].as_str().unwrap_or("").to_string(),
+                    tokens_generated: v["tokens_generated"].as_u64().unwrap_or(0),
+                }).into_response()
+            }
+        }
+        Ok(Err(_)) => {
+            // Oneshot-kanava sulkeutui (solmu katosi)
+            state.pending_responses.lock().unwrap().remove(&payload.task_id);
+            (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Verkkovirhe: yhteys katkesi").into_response()
+        }
+        Err(_) => {
+            state.pending_responses.lock().unwrap().remove(&payload.task_id);
+            (axum::http::StatusCode::GATEWAY_TIMEOUT, "Aikakatkaisu: solmu ei saanut tehtävää ajoissa valmiiksi").into_response()
+        }
     }
 }

network-poc/install.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+# Kipinä Agentic Studio — asennusskripti (Debian/Ubuntu)
+set -e
+
+echo "=== Kipinä Agentic Studio — Asennus ==="
+echo ""
+
+# Tarkistetaan käyttöjärjestelmä
+if [ ! -f /etc/debian_version ]; then
+    echo "⚠ Tämä skripti on suunniteltu Debian/Ubuntu-järjestelmille."
+    echo "  Muilla jakeluilla voit asentaa riippuvuudet manuaalisesti."
+    read -p "  Jatketaanko? (k/e) " -n 1 -r; echo
+    [[ $REPLY =~ ^[Kk]$ ]] || exit 1
+fi
+
+echo "[1/6] Päivitetään pakettilistaus..."
+sudo apt-get update -qq
+
+echo "[2/6] Asennetaan peruspaketteja..."
+sudo apt-get install -y -qq curl git build-essential pkg-config libssl-dev
+
+# Rust
+if command -v rustc &>/dev/null; then
+    echo "[3/6] Rust löytyi: $(rustc --version)"
+else
+    echo "[3/6] Asennetaan Rust..."
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+    source "$HOME/.cargo/env"
+fi
+
+# Node.js (Astro-frontend vaatii)
+if command -v node &>/dev/null; then
+    echo "[4/6] Node.js löytyi: $(node --version)"
+else
+    echo "[4/6] Asennetaan Node.js 22..."
+    curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
+    sudo apt-get install -y -qq nodejs
+fi
+
+# Ollama
+if command -v ollama &>/dev/null; then
+    echo "[5/6] Ollama löytyi"
+else
+    echo "[5/6] Asennetaan Ollama..."
+    curl -fsSL https://ollama.ai/install.sh | sh
+fi
+
+# Malli
+echo "[6/6] Ladataan kielimalli (qwen2.5-coder:3b)..."
+ollama pull qwen2.5-coder:3b
+
+echo ""
+echo "=== Asennus valmis! ==="
+echo ""
+echo "Käynnistä:"
+echo "  cd $(pwd)"
+echo "  ./network-poc/local.sh"
+echo ""
+echo "Avaa selaimessa: http://localhost:3000"

network-poc/local.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+echo "=== Kipinä Studio Local Development ==="
+
+# Frontend
+echo "[1/3] Rakennetaan frontend..."
+cd "$SCRIPT_DIR/frontend"
+[ -d node_modules ] || npm install --silent
+npm run build --silent 2>&1 | tail -1
+
+# Hub
+echo "[2/3] Käynnistetään hub..."
+cd "$SCRIPT_DIR/hub"
+cargo run &
+HUB_PID=$!
+sleep 3
+
+# Native-node (jos Ollama on käynnissä)
+if curl -s http://localhost:11434/api/tags >/dev/null 2>&1; then
+    echo "[3/3] Ollama löytyi — käynnistetään native-node..."
+    cd "$SCRIPT_DIR/native-node"
+    HUB_URL=ws://localhost:3000/ws cargo run --no-default-features &
+    NODE_PID=$!
+    echo "      Native-node PID: $NODE_PID"
+else
+    echo "[3/3] Ollama ei käynnissä — käytetään selaimen Wasm-laskentaa"
+    echo "      Nopeampi: ollama serve & ollama pull qwen2.5-coder:7b && ./local.sh"
+fi
+
+echo ""
+echo "=== http://localhost:3000 ==="
+echo "    Ctrl+C pysäyttää"
+
+# Odotetaan hub-prosessia
+wait $HUB_PID

network-poc/native-node.log

@@ -0,0 +1,208 @@
+2026-04-12T02:49:51.405400Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:49:51.422359Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:49:51.437017Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:49:51.437041Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:49:51.441582Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:50:03.018835Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:50:03.036749Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:50:03.052051Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:50:03.052084Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:50:03.056985Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:50:14.540287Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:50:14.558901Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:50:14.572180Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:50:14.572210Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:50:14.575891Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:52:05.405865Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:52:05.422571Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:52:05.433853Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:52:05.433870Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:52:05.437718Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:52:11.707486Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:52:11.707646Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T02:52:12.713480Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T02:52:12.713706Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T02:52:12.713749Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:52:12.719515Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T02:52:22.800662Z  INFO native_node: Tauotetaan solmun suoritus (Hub ei lähetä tehtäviä)...
+2026-04-12T02:52:25.475326Z  INFO native_node: Jatketaan solmun suoritusta...
+2026-04-12T02:52:28.692378Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:52:28.708978Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:52:28.723045Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:52:28.723071Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:52:28.728130Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:52:30.362566Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:52:30.362707Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T02:52:31.248236Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T02:52:31.248469Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T02:52:31.248505Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:52:31.254260Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T02:53:35.385696Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:53:35.401489Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:53:35.412450Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:53:35.412471Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:53:35.416006Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:53:44.463643Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:53:44.463794Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T02:53:45.213997Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T02:53:45.214232Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T02:53:45.214287Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T02:53:45.233548Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T02:57:27.480736Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:57:27.497388Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:57:27.508598Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:57:27.508629Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:57:27.512329Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:57:27.512356Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:3b
+2026-04-12T02:57:27.512365Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:3b...
+2026-04-12T02:57:28.357205Z  INFO native_node::inference: Malli qwen2.5-coder:3b valmis
+2026-04-12T02:57:28.357432Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T02:57:28.357489Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:3b
+2026-04-12T02:57:28.365906Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T02:57:50.406189Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T02:57:50.423119Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T02:57:50.433561Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T02:57:50.433582Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T02:57:50.437105Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T02:57:54.978974Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:3b
+2026-04-12T02:57:54.979107Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:3b...
+2026-04-12T02:57:55.795772Z  INFO native_node::inference: Malli qwen2.5-coder:3b valmis
+2026-04-12T02:57:55.796000Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T02:57:55.796037Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:3b
+2026-04-12T02:57:55.800614Z  WARN native_node: Hubiin yhdistäminen epäonnistui: IO error: Connection refused (os error 61) — yritetään uudelleen 5s...
+2026-04-12T02:58:00.808617Z  WARN native_node: Hubiin yhdistäminen epäonnistui: IO error: Connection refused (os error 61) — yritetään uudelleen 5s...
+2026-04-12T02:58:05.810771Z  WARN native_node: Hubiin yhdistäminen epäonnistui: IO error: Connection refused (os error 61) — yritetään uudelleen 5s...
+2026-04-12T02:58:10.813443Z  WARN native_node: Hubiin yhdistäminen epäonnistui: IO error: Connection refused (os error 61) — yritetään uudelleen 5s...
+2026-04-12T03:01:16.781321Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T03:01:16.794319Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T03:01:16.806165Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T03:01:16.806188Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T03:01:16.810275Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T03:01:18.325121Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:3b
+2026-04-12T03:01:18.325250Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:3b...
+2026-04-12T03:01:20.454444Z  INFO native_node::inference: Malli qwen2.5-coder:3b valmis
+2026-04-12T03:01:20.454587Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T03:01:20.454618Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:3b
+2026-04-12T03:01:20.468023Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T03:02:28.510843Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T03:02:28.526577Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T03:02:28.539782Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T03:02:28.539802Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T03:02:28.545400Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T03:02:32.541462Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:02:32.541603Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T03:02:33.365087Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T03:02:33.365313Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T03:02:33.365349Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:02:33.401538Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T03:06:31.660670Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T03:06:31.676386Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T03:06:31.690957Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T03:06:31.690977Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T03:06:31.696155Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T03:06:33.075746Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:06:33.075900Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T03:06:34.006750Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T03:06:34.006975Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T03:06:34.007013Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:06:34.012582Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T03:06:42.497863Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:06:46.162703Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 3664ms | 59.1 tok/s
+2026-04-12T03:06:49.156537Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:06:49.655724Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 20 tok | 499ms | 57.5 tok/s
+2026-04-12T03:06:52.299481Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:06:52.614573Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 314ms | 59.9 tok/s
+2026-04-12T03:07:04.444950Z  INFO native_node: → task_id:f889ae9e-ff18-4867-826a-1399ce39ea11 | 41r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:07:10.060424Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 220 tok | 5615ms | 47.8 tok/s
+2026-04-12T03:07:10.065996Z  INFO native_node: → task_id:52aaf7f1-7d6a-48df-9329-702bf4438329 | 64r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:07:13.387062Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 54 tok | 3320ms | 37.3 tok/s
+2026-04-12T03:07:13.394231Z  INFO native_node: → task_id:bea80c1b-84f3-4859-8372-a01947a181f5 | 122r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:07:28.815501Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 435 tok | 15420ms | 33.8 tok/s
+2026-04-12T03:07:28.849290Z  INFO native_node: → task_id:b33bfb94-5ea3-4483-bea6-6eae2e87f622 | 130r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:07:33.403851Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 73 tok | 4554ms | 36.0 tok/s
+2026-04-12T03:07:33.410281Z  INFO native_node: → task_id:c7271b5b-9572-4c2d-b1ca-8573153eb818 | 124r prompti | "dev = "uvicorn main:app --reload"..."
+2026-04-12T03:07:36.058218Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 3 tok | 2647ms | 66.7 tok/s
+2026-04-12T03:07:36.063363Z  INFO native_node: → task_id:3f197227-4c45-4a17-8980-0f9d523b104a | 126r prompti | "Write a complete test_main.py file with TestClient...."
+2026-04-12T03:08:04.081504Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 818 tok | 28017ms | 32.6 tok/s
+2026-04-12T03:08:04.089182Z  INFO native_node: → task_id:95ff2b0d-b2e8-483b-83a4-68d7227a4784 | 28r prompti | "Write ONLY the Dockerfile, no explanations...."
+2026-04-12T03:08:08.956198Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 127 tok | 4866ms | 33.3 tok/s
+2026-04-12T03:08:08.962241Z  INFO native_node: → task_id:70a6888c-1327-462f-81e0-238d75c80e27 | 298r prompti | "CMD ["uv", "run", "uvicorn", "main:app", "--host", "0.0.0.0"..."
+2026-04-12T03:08:20.512602Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 170 tok | 11550ms | 31.8 tok/s
+2026-04-12T03:10:23.640488Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:24.016781Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 376ms | 59.8 tok/s
+2026-04-12T03:10:28.471504Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:28.851913Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 380ms | 56.4 tok/s
+2026-04-12T03:10:32.080898Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:32.761760Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 30 tok | 680ms | 56.2 tok/s
+2026-04-12T03:10:33.543595Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:34.155195Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 27 tok | 611ms | 56.8 tok/s
+2026-04-12T03:10:37.170032Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:37.490844Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 320ms | 59.3 tok/s
+2026-04-12T03:10:41.071790Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:41.393921Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 321ms | 58.8 tok/s
+2026-04-12T03:10:47.007835Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:47.352103Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 344ms | 56.9 tok/s
+2026-04-12T03:10:55.861324Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:10:56.193953Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 332ms | 57.8 tok/s
+2026-04-12T03:11:09.557527Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:11:09.890235Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 332ms | 58.7 tok/s
+2026-04-12T03:11:11.846667Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:11:12.166974Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 320ms | 59.8 tok/s
+2026-04-12T03:11:22.243681Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:11:22.590303Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 346ms | 56.8 tok/s
+2026-04-12T03:11:43.577820Z  INFO native_node: → task_id:0d939424-723a-4898-b182-e9959e16abb9 | 41r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:11:50.105047Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 256 tok | 6527ms | 47.0 tok/s
+2026-04-12T03:11:50.147446Z  INFO native_node: → task_id:a3492a26-284c-4874-80b6-4aeafdbb5a75 | 69r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:11:53.451037Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 55 tok | 3303ms | 39.0 tok/s
+2026-04-12T03:11:53.459737Z  INFO native_node: → task_id:7cc73c11-57a8-4cf2-be31-7302e81d25c7 | 127r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:12:08.447730Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 435 tok | 14987ms | 35.1 tok/s
+2026-04-12T03:12:08.455128Z  INFO native_node: → task_id:a7adc096-78b1-4314-93a2-26824e2c6ab1 | 135r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:12:13.297818Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 73 tok | 4842ms | 36.0 tok/s
+2026-04-12T03:12:13.308601Z  INFO native_node: → task_id:cda5ff01-e88e-4c58-bf5d-24d7a449b4b2 | 128r prompti | "dev = "uvicorn main:app --reload"..."
+2026-04-12T03:12:16.062246Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 3 tok | 2753ms | 70.0 tok/s
+2026-04-12T03:12:16.070379Z  INFO native_node: → task_id:8d04d6eb-2439-4038-8ffe-ea37eec8d673 | 128r prompti | "Write a complete test_main.py file with TestClient...."
+2026-04-12T03:12:40.311815Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 788 tok | 24240ms | 36.7 tok/s
+2026-04-12T03:12:40.348709Z  INFO native_node: → task_id:b112c319-e2ad-4293-8699-4feb4f7cee5e | 30r prompti | "Write ONLY the Dockerfile, no explanations...."
+2026-04-12T03:12:45.108493Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 145 tok | 4759ms | 38.6 tok/s
+2026-04-12T03:12:45.151914Z  INFO native_node: → task_id:80d8e1cf-d536-4ac4-9577-08fbab53d159 | 295r prompti | "EXPOSE 8000..."
+2026-04-12T03:12:55.265794Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 171 tok | 10113ms | 36.7 tok/s
+2026-04-12T03:18:26.329119Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T03:18:26.350176Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T03:18:26.367757Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T03:18:26.367784Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T03:18:26.374430Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T03:18:29.330257Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:18:29.330419Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T03:18:30.297228Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T03:18:30.297413Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T03:18:30.297502Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:18:30.304013Z  INFO native_node: Yhdistetty hubiin!
+2026-04-12T03:19:02.300905Z  INFO native_node: → task_id:status-check | 1r prompti | "ping..."
+2026-04-12T03:19:03.443612Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 11 tok | 1142ms | 58.2 tok/s
+2026-04-12T03:19:11.592789Z  INFO native_node: → task_id:3625298a-8cf3-4cfc-b24f-96eb7d8487c3 | 41r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:19:17.955448Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 253 tok | 6362ms | 47.9 tok/s
+2026-04-12T03:19:17.965059Z  INFO native_node: → task_id:d8d651b2-2d1b-4652-91c7-0e3d99f12ead | 69r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:19:21.159047Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 54 tok | 3193ms | 40.3 tok/s
+2026-04-12T03:19:21.167536Z  INFO native_node: → task_id:fa5f4645-a440-4624-83a6-fb24799d0edc | 127r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:19:35.681742Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 435 tok | 14513ms | 36.2 tok/s
+2026-04-12T03:19:35.691591Z  INFO native_node: → task_id:24684ea4-2b1b-41c2-b2b0-068fb4e38483 | 136r prompti | "Adapt the example to match the project description. Import f..."
+2026-04-12T03:19:40.236213Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 76 tok | 4544ms | 37.9 tok/s
+2026-04-12T03:19:40.244741Z  INFO native_node: → task_id:d4e407e9-a0fd-4b25-b355-317e16851854 | 129r prompti | "dev = "uv run uvicorn main:app --reload"..."
+2026-04-12T03:19:43.089356Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 3 tok | 2844ms | 67.8 tok/s
+2026-04-12T03:19:43.099954Z  INFO native_node: → task_id:7fa43b8d-8ed1-4f44-be45-bc99619ae74f | 129r prompti | "Write a complete test_main.py file with TestClient...."
+2026-04-12T03:20:08.686318Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 773 tok | 25585ms | 34.0 tok/s
+2026-04-12T03:20:08.696389Z  INFO native_node: → task_id:98a7c691-29f8-4385-9fe6-389d0edfb404 | 30r prompti | "Write ONLY the Dockerfile, no explanations...."
+2026-04-12T03:20:12.560366Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 100 tok | 3863ms | 36.6 tok/s
+2026-04-12T03:20:12.569728Z  INFO native_node: → task_id:b95245cb-6c5a-4a8e-b903-40f7471d2e72 | 289r prompti | "CMD ["uv", "run", "uvicorn", "main:app", "--host", "0.0.0.0"..."
+2026-04-12T03:20:22.658899Z  INFO native_node: ✓ qwen2.5-coder:7b-instruct-q4_K_M | 174 tok | 10089ms | 36.3 tok/s
+2026-04-12T03:21:37.867699Z  INFO native_node: Kipinä Native Node käynnistyy — hub: ws://127.0.0.1:3000/ws, varaus: 4 GB
+2026-04-12T03:21:37.879381Z  INFO native_node: Järjestelmä: Mac | Darwin 26.3.1 | 12 ydintä | 32768 MB RAM
+2026-04-12T03:21:37.899474Z  INFO native_node: GPU 0: Apple M2 Max (Apple) [Metal] | VRAM: ?/24576 MB | ? | kuormitus: ?
+2026-04-12T03:21:37.899494Z  INFO native_node: Alustetaan Ollama-yhteyttä...
+2026-04-12T03:21:37.903580Z  INFO native_node::inference: Ollama löytyi osoitteesta: http://localhost:11434
+2026-04-12T03:21:48.551879Z  INFO native_node::inference: Ollama backend: http://localhost:11434 | malli: qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:21:48.552045Z  INFO native_node::inference: Tarkistetaan malli qwen2.5-coder:7b-instruct-q4_K_M...
+2026-04-12T03:21:49.569609Z  INFO native_node::inference: Malli qwen2.5-coder:7b-instruct-q4_K_M valmis
+2026-04-12T03:21:49.569839Z  INFO native_node: Ollama valmis inferenssiin!
+2026-04-12T03:21:49.569961Z  INFO native_node: Käytettävä kielimalli konfiguroitu (selected_task): qwen2.5-coder:7b-instruct-q4_K_M
+2026-04-12T03:21:49.577531Z  INFO native_node: Yhdistetty hubiin!

network-poc/native-node/Cargo.toml

@@ -1,8 +1,12 @@
 [package]
 name = "native-node"
-version = "0.1.0"
+version = "0.2.2"
 edition = "2024"
 
+[features]
+default = ["gpu-detect"]
+gpu-detect = ["nvml-wrapper", "wgpu"]
+
 [dependencies]
 tokio = { version = "1.36", features = ["full"] }
 tokio-tungstenite = { version = "0.21", features = ["native-tls"] }
@@ -10,12 +14,13 @@ futures-util = "0.3"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 sysinfo = "0.30"
-nvml-wrapper = "0.10"
+nvml-wrapper = { version = "0.10", optional = true }
-wgpu = "24"
+wgpu = { version = "24", optional = true }
-candle-core = { version = "0.8", features = ["cuda"] }
+reqwest = { version = "0.12", features = ["json"] }
-candle-nn = "0.8"
-candle-transformers = "0.8"
-hf-hub = "0.4"
-tokenizers = "0.19"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+dialoguer = "0.12.0"
+console = "0.16.3"
+ratatui = "0.29.0"
+crossterm = { version = "0.28.1", features = ["event-stream"] }
+tracing-appender = "0.2.4"

network-poc/native-node/src/inference.rs

@@ -1,292 +1,184 @@
-use candle_core::{Device, Tensor, DType};
-use candle_nn::VarBuilder;
-use candle_transformers::models::qwen2::{Config as QwenConfig, ModelForCausalLM as QwenModel};
-use hf_hub::{api::sync::Api, Repo, RepoType};
 use std::time::Instant;
-
+use std::cell::RefCell;
-/// Top-k sampling with temperature and repetition penalty
-fn sample_top_k(logits: &Tensor, k: usize, temperature: f64, generated_tokens: &[u32], repetition_penalty: f64, rng_state: &mut u64) -> Result<u32, String> {
-    let mut logits_vec: Vec<f32> = logits.to_vec1::<f32>().map_err(|e| format!("to_vec1: {}", e))?;
-    if logits_vec.is_empty() { return Err("Tyhjä logits".to_string()); }
-
-    // Repetition penalty: rankaisee jo generoituja tokeneita
-    for &token_id in generated_tokens {
-        if (token_id as usize) < logits_vec.len() {
-            let logit = &mut logits_vec[token_id as usize];
-            if *logit > 0.0 {
-                *logit /= repetition_penalty as f32;
-            } else {
-                *logit *= repetition_penalty as f32;
-            }
-        }
-    }
-
-    // Temperature scaling
-    if temperature > 0.0 && temperature != 1.0 {
-        for logit in logits_vec.iter_mut() {
-            *logit /= temperature as f32;
-        }
-    }
-
-    // Top-k: etsitään k suurinta
-    let mut indexed: Vec<(usize, f32)> = logits_vec.iter().enumerate().map(|(i, &v)| (i, v)).collect();
-    indexed.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
-    indexed.truncate(k);
-
-    if k == 1 || temperature == 0.0 {
-        return Ok(indexed[0].0 as u32);
-    }
-
-    // Softmax top-k:lle
-    let max_logit = indexed[0].1;
-    let exps: Vec<f32> = indexed.iter().map(|x| (x.1 - max_logit).exp()).collect();
-    let sum: f32 = exps.iter().sum();
-    let probs: Vec<f32> = exps.iter().map(|e| e / sum).collect();
-
-    // XorShift64 RNG
-    *rng_state ^= *rng_state << 13;
-    *rng_state ^= *rng_state >> 7;
-    *rng_state ^= *rng_state << 17;
-    let rand_val = (*rng_state % 10000) as f32 / 10000.0;
-
-    let mut cumulative = 0.0;
-    for (i, p) in probs.iter().enumerate() {
-        cumulative += p;
-        if rand_val < cumulative {
-            return Ok(indexed[i].0 as u32);
-        }
-    }
-
-    Ok(indexed[0].0 as u32)
-}
 
 pub struct LlmEngine {
-    tokenizer: tokenizers::Tokenizer,
+    ollama_url: String,
-    model: QwenModel,
+    model: RefCell<String>,
-    device: Device,
+    client: reqwest::Client,
-    eos_token: u32,
 }
 
 impl LlmEngine {
-    pub fn load() -> Result<Self, String> {
+    pub async fn load() -> Result<Self, String> {
-        let device = Device::cuda_if_available(0).map_err(|e| format!("Device: {}", e))?;
+        let client = reqwest::Client::builder()
-        let device_name = if device.is_cuda() { "CUDA" } else { "CPU" };
+            .timeout(std::time::Duration::from_secs(600))
-        tracing::info!("LLM device: {}", device_name);
+            .connect_timeout(std::time::Duration::from_secs(3))
+            .build()
+            .map_err(|e| format!("HTTP client: {}", e))?;
 
-        let dtype = if device.is_cuda() { DType::F16 } else { DType::F32 };
+        // Jos OLLAMA_URL on asetettu, käytetään sitä suoraan
-
+        let ollama_url = if let Ok(url) = std::env::var("OLLAMA_URL") {
-        tracing::info!("Ladataan Qwen2.5-Coder-0.5B-Instruct...");
+            tracing::info!("Ollama backend (env): {}", url);
-        let api = Api::new().map_err(|e| format!("HF API: {}", e))?;
+            url
-        let repo = api.repo(Repo::with_revision(
-            "Qwen/Qwen2.5-Coder-0.5B-Instruct".to_string(),
-            RepoType::Model,
-            "main".to_string(),
-        ));
-
-        let tokenizer_path = repo.get("tokenizer.json").map_err(|e| format!("Tokenizer lataus: {}", e))?;
-        let model_path = repo.get("model.safetensors").map_err(|e| format!("Malli lataus: {}", e))?;
-
-        tracing::info!("Ladataan tokenizer: {:?}", tokenizer_path);
-        let tokenizer = tokenizers::Tokenizer::from_file(&tokenizer_path)
-            .map_err(|e| format!("Tokenizer: {}", e))?;
-
-        let config = QwenConfig {
-            vocab_size: 151936,
-            hidden_size: 896,
-            intermediate_size: 4864,
-            num_hidden_layers: 24,
-            num_attention_heads: 14,
-            num_key_value_heads: 2,
-            max_position_embeddings: 32768,
-            sliding_window: 32768,
-            max_window_layers: 21,
-            tie_word_embeddings: true,
-            rope_theta: 1000000.0,
-            rms_norm_eps: 1e-6,
-            use_sliding_window: false,
-            hidden_act: candle_nn::Activation::Silu,
-        };
-
-        let start = Instant::now();
-        let vb = unsafe {
-            VarBuilder::from_mmaped_safetensors(&[model_path.clone()], dtype, &device)
-                .map_err(|e| format!("VarBuilder: {}", e))?
-        };
-        let model = QwenModel::new(&config, vb).map_err(|e| format!("Malli: {}", e))?;
-        tracing::info!("Malli ladattu ({:.1}s) — {}", start.elapsed().as_secs_f64(), device_name);
-
-        Ok(LlmEngine {
-            tokenizer,
-            model,
-            device,
-            eos_token: 151645,
-        })
-    }
-
-    pub fn generate(&mut self, prompt: &str, max_tokens: usize) -> Result<GenerateResult, String> {
-        // Prefill: aloitetaan vastaus ```-koodiblokkilla → malli jatkaa suoraan koodilla
-        let formatted = format!("<|im_start|>system\nYou are a coding assistant. Respond with ONLY code. No explanations, no markdown, no comments unless asked.<|im_end|>\n<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n```\n", prompt);
-
-        let encoding = self.tokenizer.encode(formatted.as_str(), true)
-            .map_err(|e| format!("Encode: {}", e))?;
-        let input_ids: Vec<u32> = encoding.get_ids().to_vec();
-        let input_len = input_ids.len();
-
-        // Nollataan KV-cache edellisestä promptista
-        self.model.clear_kv_cache();
-
-        // Sampling-parametrit
-        let temperature = 0.7;
-        let top_k = 40;
-        let repetition_penalty = 1.15;
-        let mut rng_state: u64 = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap()
-            .as_nanos() as u64;
-
-        let start = Instant::now();
-
-        // Prefill
-        let input = Tensor::new(input_ids.as_slice(), &self.device)
-            .and_then(|t| t.unsqueeze(0))
-            .map_err(|e| format!("Tensor: {}", e))?;
-
-        let logits = self.model.forward(&input, 0)
-            .map_err(|e| format!("Forward prefill: {}", e))?;
-
-        let logits = logits.squeeze(0).map_err(|e| format!("Squeeze: {}", e))?;
-        let logits = if logits.dims().len() == 2 {
-            let seq_len = logits.dim(0).map_err(|e| format!("Dim: {}", e))?;
-            if seq_len == 0 { return Err("Tyhjä tensori".to_string()); }
-            logits.get(seq_len - 1).map_err(|e| format!("Get: {}", e))?
         } else {
-            logits
+            // Haistellaan Ollamaa tunnetuista osoitteista
-        };
+            let candidates = [
-
+                "http://localhost:11434",
-        let mut generated_text = String::new();
+                "http://127.0.0.1:11434",
-        let mut tokens_generated: usize = 0;
+                "http://ollama:11434",
-        let mut all_tokens: Vec<u32> = Vec::new();
+                "http://host.docker.internal:11434",
-
+            ];
-        let mut next_token = sample_top_k(&logits, top_k, temperature, &all_tokens, repetition_penalty, &mut rng_state)?;
+            let mut found = None;
-
+            for url in &candidates {
-        if next_token != self.eos_token {
+                let probe = reqwest::Client::builder()
-            if let Ok(text) = self.tokenizer.decode(&[next_token], true) {
+                    .connect_timeout(std::time::Duration::from_secs(2))
-                generated_text.push_str(&text);
+                    .build().unwrap_or(client.clone());
-            }
+                if let Ok(resp) = probe.get(format!("{}/api/version", url)).send().await {
-            all_tokens.push(next_token);
+                    if resp.status().is_success() {
-            tokens_generated += 1;
+                        tracing::info!("Ollama löytyi osoitteesta: {}", url);
-        }
+                        found = Some(url.to_string());
-
+                        break;
-        // Autoregressive
-        let mut pos = input_len;
-        for _ in 1..max_tokens {
-            if next_token == self.eos_token { break; }
-
-            let input = Tensor::new(&[next_token], &self.device)
-                .and_then(|t| t.unsqueeze(0))
-                .map_err(|e| format!("Tensor: {}", e))?;
-
-            let logits = self.model.forward(&input, pos)
-                .map_err(|e| format!("Forward pos {}: {}", pos, e))?;
-
-            let logits = logits.squeeze(0).map_err(|e| format!("Squeeze: {}", e))?;
-            let logits = if logits.dims().len() == 2 {
-                let seq_len = logits.dim(0).map_err(|e| format!("Dim: {}", e))?;
-                if seq_len == 0 { break; }
-                logits.get(seq_len - 1).map_err(|e| format!("Get: {}", e))?
-            } else {
-                logits
-            };
-            next_token = sample_top_k(&logits, top_k, temperature, &all_tokens, repetition_penalty, &mut rng_state)?;
-            pos += 1;
-
-            if next_token == self.eos_token { break; }
-
-            if let Ok(text) = self.tokenizer.decode(&[next_token], true) {
-                generated_text.push_str(&text);
-
-                // Stop-sekvenssit: katkaistaan kun malli alkaa selittää
-                let lower = generated_text.to_lowercase();
-                if lower.contains("\n###") || lower.contains("\nexplanation") || lower.contains("\nnote:") || lower.contains("\noutput:") || lower.contains("\n```\n\n") || lower.contains("\n// example") || lower.contains("\n# example") {
-                    for stop in &["\n###", "\nExplanation", "\nNote:", "\nOutput:", "\n```\n\n", "\n// Example", "\n// example", "\n# Example", "\n# example"] {
-                        if let Some(pos) = generated_text.find(stop) {
-                            generated_text.truncate(pos);
-                        }
                     }
-                    break;
                 }
             }
-            all_tokens.push(next_token);
+            found.unwrap_or_else(|| {
-            tokens_generated += 1;
+                tracing::warn!("Ollamaa ei löytynyt — käytetään oletusta http://localhost:11434");
+                "http://localhost:11434".to_string()
+            })
+        };
+
+        // Kysytään malli TUI:lla jos ei pakotettu ympäristöstä
+        let model = match std::env::var("OLLAMA_MODEL") {
+            Ok(m) if !m.is_empty() => m,
+            _ => crate::tui::select_model(&ollama_url, &client).await?
+        };
+
+        tracing::info!("Ollama backend: {} | malli: {}", ollama_url, model);
+        Ok(LlmEngine { ollama_url, model: RefCell::new(model), client })
+    }
+
+    pub fn model_name(&self) -> String {
+        self.model.borrow().clone()
+    }
+
+    pub fn set_model(&self, new_model: String) {
+        *self.model.borrow_mut() = new_model;
+    }
+
+    /// Varmistaa että malli on ladattu Ollamaan (ollama pull)
+    pub async fn ensure_model(&self) -> Result<(), String> {
+        let model = self.model.borrow().clone();
+        tracing::info!("Tarkistetaan malli {}...", model);
+        let resp = self.client.post(format!("{}/api/pull", self.ollama_url))
+            .json(&serde_json::json!({ "name": model, "stream": false }))
+            .send()
+            .await
+            .map_err(|e| format!("Ollama pull: {}", e))?;
+
+        if resp.status().is_success() {
+            tracing::info!("Malli {} valmis", model);
+            Ok(())
+        } else {
+            Err(format!("Ollama pull epäonnistui: {}", resp.status()))
+        }
+    }
+
+    /// Hakee kaikki Ollamaan asennetut mallit
+    pub async fn fetch_models(&self) -> Result<serde_json::Value, String> {
+        let resp = self.client.get(format!("{}/api/tags", self.ollama_url))
+            .send()
+            .await
+            .map_err(|e| format!("Ollama tags fetch: {}", e))?;
+
+        if resp.status().is_success() {
+            resp.json().await.map_err(|e| format!("Ollama tags json: {}", e))
+        } else {
+            Err(format!("Ollama tags epäonnistui: {}", resp.status()))
+        }
+    }
+
+    pub async fn generate(&self, prompt: &str, max_tokens: usize) -> Result<GenerateResult, String> {
+        // System prompt tulee agentin konfiguraatiosta (frontend lähettää sen osana promptia).
+        // Tässä ei yliajeta sitä — Ollama saa vain prompt-kentän.
+        let model = self.model.borrow().clone();
+
+        let start = Instant::now();
+        let resp = self.client.post(format!("{}/api/generate", self.ollama_url))
+            .json(&serde_json::json!({
+                "model": model,
+                "prompt": prompt,
+                "stream": false,
+                "options": {
+                    "num_predict": max_tokens,
+                    "temperature": 0.7,
+                    "top_k": 40,
+                    "repeat_penalty": 1.15,
+                    "stop": ["<|im_end|>", "\n###", "\nExplanation", "\nNote:", "\nPlease note", "\nThis is", "\n```\n\n", "\n// Example", "\n# Example"]
+                }
+            }))
+            .send()
+            .await
+            .map_err(|e| format!("Ollama generate: {}", e))?;
+
+        if !resp.status().is_success() {
+            return Err(format!("Ollama HTTP {}", resp.status()));
         }
 
-        let gen_time = start.elapsed();
+        let body: serde_json::Value = resp.json().await
-        let tokens_per_sec = if gen_time.as_secs_f64() > 0.0 {
+            .map_err(|e| format!("Ollama JSON: {}", e))?;
-            tokens_generated as f64 / gen_time.as_secs_f64()
+
+        let text = body["response"].as_str().unwrap_or("").to_string();
+        let _total_duration_ns = body["total_duration"].as_u64().unwrap_or(0);
+        let eval_count = body["eval_count"].as_u64().unwrap_or(0) as usize;
+        let eval_duration_ns = body["eval_duration"].as_u64().unwrap_or(1);
+
+        let duration_ms = start.elapsed().as_millis() as f64;
+        let tokens_per_sec = if eval_duration_ns > 0 {
+            eval_count as f64 / (eval_duration_ns as f64 / 1_000_000_000.0)
         } else { 0.0 };
 
         Ok(GenerateResult {
-            text: strip_markdown_wrapper(&generated_text),
+            text: strip_code_fences(&text),
-            tokens_generated,
+            tokens_generated: eval_count,
-            duration_ms: gen_time.as_millis() as f64,
+            duration_ms,
             tokens_per_sec,
         })
     }
 }
 
-const LANG_TAGS: &[&str] = &[
+/// Siivoa markdown-koodiblokki-merkit ja selitystekstit
-    "python", "py", "rust", "rs", "javascript", "js", "typescript", "ts",
+fn strip_code_fences(text: &str) -> String {
-    "java", "kotlin", "scala", "go", "ruby", "rb", "php", "swift",
+    // Poistetaan kaikki ```-rivit ja kielitunnisteet (```python, ```rust jne.)
-    "c", "cpp", "c++", "c#", "csharp", "r", "sql", "bash", "sh", "zsh",
+    let lines: Vec<&str> = text.lines().collect();
-    "html", "css", "json", "yaml", "yml", "toml", "xml", "markdown", "md",
+    let filtered: Vec<&str> = lines.into_iter().filter(|line| {
-    "lua", "perl", "dart", "elixir", "haskell", "hs", "ocaml", "zig",
+        let trimmed = line.trim();
-    "plaintext", "text", "txt",
+        // Poista rivit jotka ovat pelkkiä ``` tai ```kielitunniste
-];
+        if trimmed.starts_with("```") {
+            return false;
+        }
+        true
+    }).collect();
+    let mut result = filtered.join("\n").trim().to_string();
 
-/// Siivoa mallin tuottama vastaus (prefill-yhteensopiva).
+    // Poista selitysteksti lopusta (kaikki rivin "\nPlease note" jälkeen jne.)
-fn strip_markdown_wrapper(text: &str) -> String {
+    let lower = result.to_lowercase();
-    let mut result = text.trim().to_string();
+    for stop in &["\nplease note", "\nthis is a basic", "\nthis code", "\nnote that", "\nremember to", "\nyou can", "\nto run"] {
-
+        if let Some(pos) = lower.find(stop) {
-    // 1. Kielitunniste — VAIN tunnettu kieli
+            result = result[..pos].trim_end().to_string();
-    if let Some(nl) = result.find('\n') {
-        let first = result[..nl].trim().to_lowercase();
-        if LANG_TAGS.contains(&first.as_str()) {
-            result = result[nl + 1..].to_string();
         }
     }
 
-    // 2. Sulkeva ``` — VAIN omalla rivillään lopussa
+    // Poista johdantolauseet alusta
-    let trimmed = result.trim_end();
+    let lower = result.to_lowercase();
-    if trimmed.ends_with("```") {
-        let before = &trimmed[..trimmed.len() - 3];
-        if before.is_empty() || before.ends_with('\n') {
-            result = before.trim_end().to_string();
-        }
-    }
-
-    // 3. Johdantolauseet
-    let lower = result.trim().to_lowercase();
     for prefix in &["sure!", "here is", "here's", "certainly!", "below is"] {
         if lower.starts_with(prefix) {
-            if let Some(nl) = result.find('\n') { result = result[nl + 1..].to_string(); }
+            if let Some(nl) = result.find('\n') {
+                result = result[nl + 1..].to_string();
+            }
             break;
         }
     }
 
-    // 4. Selityskommentit alusta
+    result.trim().to_string()
-    let mut lines: Vec<&str> = result.trim().lines().collect();
-    while !lines.is_empty() {
-        let first = lines[0].trim();
-        let is_preamble = first.starts_with("# ") && !first.starts_with("#!")
-            && (first.to_lowercase().contains("this is")
-                || first.to_lowercase().contains("simple")
-                || first.to_lowercase().contains("program that")
-                || first.to_lowercase().contains("here is")
-                || first.to_lowercase().contains("the following")
-                || first.to_lowercase().contains("below"));
-        if is_preamble { lines.remove(0); } else { break; }
-    }
-    lines.join("\n").trim().to_string()
 }
 
 pub struct GenerateResult {

network-poc/native-node/src/main.rs

@@ -5,6 +5,8 @@ use tokio_tungstenite::connect_async;
 use tokio_tungstenite::tungstenite::Message;
 
 mod inference;
+mod tui;
+mod tui_dashboard;
 
 /// GPU-tietorakenne — yhtenäinen kaikille valmistajille
 struct GpuInfo {
@@ -33,6 +35,7 @@ impl GpuInfo {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Tunnistaa kaikki GPU:t wgpu:lla (NVIDIA/AMD/Apple/Intel)
 fn collect_gpus_wgpu() -> Vec<GpuInfo> {
     let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
@@ -84,6 +87,7 @@ fn collect_gpus_wgpu() -> Vec<GpuInfo> {
     gpus
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Täydentää NVIDIA-GPU:iden tiedot NVML:llä (VRAM, lämpötila, kuormitus)
 fn enrich_nvidia_gpus(gpus: &mut [GpuInfo]) {
     let Ok(nvml) = nvml_wrapper::Nvml::init() else { return };
@@ -109,6 +113,7 @@ fn enrich_nvidia_gpus(gpus: &mut [GpuInfo]) {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 /// AMD GPU-tiedot Linuxin sysfs:stä (/sys/class/drm/)
 fn enrich_amd_gpus(gpus: &mut [GpuInfo]) {
     let Ok(entries) = std::fs::read_dir("/sys/class/drm") else { return };
@@ -150,10 +155,12 @@ fn enrich_amd_gpus(gpus: &mut [GpuInfo]) {
     }
 }
 
+#[cfg(feature = "gpu-detect")]
 fn read_sysfs_u64(path: &std::path::Path) -> Option<u64> {
     std::fs::read_to_string(path).ok()?.trim().parse().ok()
 }
 
+#[cfg(feature = "gpu-detect")]
 fn find_hwmon_temp(device_path: &std::path::Path) -> Option<u64> {
     let hwmon_dir = device_path.join("hwmon");
     let entries = std::fs::read_dir(&hwmon_dir).ok()?;
@@ -166,8 +173,8 @@ fn find_hwmon_temp(device_path: &std::path::Path) -> Option<u64> {
     None
 }
 
+#[cfg(feature = "gpu-detect")]
 /// Apple GPU-tiedot — wgpu/Metal antaa nimen, tarkempaa dataa ei saa ilman IOKit:ia
-/// mutta Metal adapter_info sisältää jo olennaiset tiedot
 fn enrich_apple_gpus(gpus: &mut [GpuInfo]) {
     // Apple Silicon -koneiden unified memory: koko RAM on GPU:n käytettävissä
     // Arvioidaan system RAM:sta
@@ -187,13 +194,18 @@ fn enrich_apple_gpus(gpus: &mut [GpuInfo]) {
 
 /// Kerää kaikki GPU:t ja täydentää valmistajakohtaiset tiedot
 fn collect_all_gpus() -> Vec<GpuInfo> {
-    let mut gpus = collect_gpus_wgpu();
+    #[cfg(feature = "gpu-detect")]
-
+    {
-    enrich_nvidia_gpus(&mut gpus);
+        let mut gpus = collect_gpus_wgpu();
-    enrich_amd_gpus(&mut gpus);
+        enrich_nvidia_gpus(&mut gpus);
-    enrich_apple_gpus(&mut gpus);
+        enrich_amd_gpus(&mut gpus);
-
+        enrich_apple_gpus(&mut gpus);
-    gpus
+        return gpus;
+    }
+    #[cfg(not(feature = "gpu-detect"))]
+    {
+        Vec::new()
+    }
 }
 
 /// Kerää järjestelmätiedot (CPU, RAM, OS)
@@ -212,7 +224,7 @@ fn collect_system_info() -> serde_json::Value {
 }
 
 /// Koko auth-viesti hubille
-fn build_auth_message(allocated_gb: u32) -> String {
+fn build_auth_message(allocated_gb: u32, model_name: &str, models_data: Option<serde_json::Value>) -> String {
     let sys = collect_system_info();
     let gpus = collect_all_gpus();
 
@@ -222,19 +234,29 @@ fn build_auth_message(allocated_gb: u32) -> String {
         v
     }).collect();
 
+    let api_key = std::env::var("NODE_API_KEY").unwrap_or_default();
+
     let mut msg = json!({
         "type": "auth",
         "status": "agent_ready",
         "node_type": "native",
         "allocated_gb": allocated_gb,
-        "selected_task": "qwen-coder-05b",
+        "selected_task": model_name,
         "system": sys,
     });
 
+    if !api_key.is_empty() {
+        msg.as_object_mut().unwrap().insert("api_key".to_string(), json!(api_key));
+    }
+
     if !gpu_json.is_empty() {
         msg.as_object_mut().unwrap().insert("gpus".to_string(), json!(gpu_json));
     }
 
+    if let Some(models) = models_data {
+        msg.as_object_mut().unwrap().insert("models".to_string(), models);
+    }
+
     msg.to_string()
 }
 
@@ -247,10 +269,24 @@ fn format_optional<T: std::fmt::Display>(val: Option<T>, suffix: &str) -> String
 
 #[tokio::main]
 async fn main() {
+    let file_appender = tracing_appender::rolling::never(".", "native-node.log");
+    let (non_blocking, _guard) = tracing_appender::non_blocking(file_appender);
+    
     tracing_subscriber::fmt()
         .with_env_filter("native_node=debug")
+        .with_writer(non_blocking)
         .init();
 
+    // Hookataan paniikkitilanteet palauttamaan terminaalin raw-moodista
+    let original_hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |panic_info| {
+        tui_dashboard::restore_terminal();
+        original_hook(panic_info);
+    }));
+
+    let tui_state = std::sync::Arc::new(tokio::sync::RwLock::new(tui_dashboard::DashboardState::new()));
+    let (cmd_tx, mut cmd_rx) = tokio::sync::mpsc::unbounded_channel::<String>();
+
     let hub_url = std::env::var("HUB_URL").unwrap_or_else(|_| "ws://hub:3000/ws".to_string());
     let allocated_gb: u32 = std::env::var("ALLOCATED_GB")
         .ok()
@@ -266,9 +302,24 @@ async fn main() {
         sys["cpu_cores"],
         sys["ram_total_mb"]
     );
+    
+    {
+        let mut st = tui_state.write().await;
+        st.sys_info = format!("{} | {} | {} ydintä | {} MB RAM",
+            sys["hostname"].as_str().unwrap_or("?"),
+            sys["os"].as_str().unwrap_or("?"),
+            sys["cpu_cores"],
+            sys["ram_total_mb"]
+        );
+        let i = st.sys_info.clone();
+        st.push_log("System", format!("Järjestelmä: {}", i), None);
+    }
 
     let gpus = collect_all_gpus();
     if gpus.is_empty() {
+        #[cfg(not(feature = "gpu-detect"))]
+        tracing::info!("GPU-tunnistus ei käytössä (--no-default-features). Ollama käyttää GPU:ta automaattisesti jos saatavilla.");
+        #[cfg(feature = "gpu-detect")]
         tracing::info!("GPU:ta ei havaittu — toimitaan CPU-moodissa");
     } else {
         for (i, gpu) in gpus.iter().enumerate() {
@@ -285,19 +336,53 @@ async fn main() {
         }
     }
 
-    // Ladataan LLM-malli
+    // Ollama-backend
-    tracing::info!("Ladataan LLM-mallia...");
+    tracing::info!("Alustetaan Ollama-yhteyttä...");
-    let mut llm = match inference::LlmEngine::load() {
+    let llm = match inference::LlmEngine::load().await {
         Ok(engine) => {
-            tracing::info!("LLM valmis inferenssiin!");
+            // Varmistetaan malli (ollama pull) — odotetaan kunnes valmis
+            match engine.ensure_model().await {
+                Ok(()) => tracing::info!("Ollama valmis inferenssiin!"),
+                Err(e) => tracing::warn!("Mallin lataus: {} — yritetään silti", e),
+            }
             Some(engine)
         }
         Err(e) => {
-            tracing::warn!("LLM-lataus epäonnistui: {} — toimitaan ilman inferenssiä", e);
+            tracing::warn!("Ollama-alustus epäonnistui: {} — toimitaan ilman inferenssiä", e);
             None
         }
     };
 
+    let active_model = llm.as_ref().map(|e| e.model_name()).unwrap_or_else(|| "unknown".to_string());
+    tracing::info!("Käytettävä kielimalli konfiguroitu (selected_task): {}", active_model);
+    
+    {
+        let mut st = tui_state.write().await;
+        st.model_name = active_model.clone();
+        st.push_log("System", format!("Malli valmis: {}", active_model), None);
+    }
+
+    // Käynnistetään graafinen TUI vasta kun TUI:n Prompt (LlmEngine::load) on ohitettu!
+    let ui_state = tui_state.clone();
+    tokio::spawn(async move {
+        if let Err(e) = tui_dashboard::run_dashboard(ui_state, cmd_tx).await {
+            tracing::error!("Pääluupin TUI kaatui: {}", e);
+        }
+    });
+
+    // Haetaan paikalliset mallit hubille lähetettäväksi
+    let mut available_models = None;
+    if let Some(ref engine) = llm {
+        match engine.fetch_models().await {
+            Ok(models) => {
+                available_models = Some(models);
+            }
+            Err(e) => {
+                tracing::warn!("Mallilistauksen haku epäonnistui: {}", e);
+            }
+        }
+    }
+
     // Yhdistetään hubiin
     loop {
         match connect_async(&hub_url).await {
@@ -305,64 +390,178 @@ async fn main() {
                 tracing::info!("Yhdistetty hubiin!");
                 let (mut write, mut read) = ws_stream.split();
 
-                let auth = build_auth_message(allocated_gb);
+                let auth = build_auth_message(allocated_gb, &active_model, available_models.clone());
                 if write.send(Message::Text(auth)).await.is_err() {
                     tracing::error!("Auth-viestin lähetys epäonnistui");
                     continue;
                 }
 
-                let mut busy = false;
+                loop {
-
+                    tokio::select! {
-                while let Some(Ok(msg)) = read.next().await {
+                        cmd = cmd_rx.recv() => {
-                    if let Message::Text(text) = msg {
+                            if let Some(cmd_str) = cmd {
-                        // LLM-promptit
+                                if cmd_str == "pause" {
-                        if text.contains("llm_prompt") && !busy {
+                                    tracing::info!("Tauotetaan solmun suoritus (Hub ei lähetä tehtäviä)...");
-                            if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
+                                    let req = json!({"type": "status_update", "status": "paused"});
-                                let prompt = task.get("prompt").and_then(|v| v.as_str()).unwrap_or("");
+                                    let _ = write.send(Message::Text(req.to_string())).await;
-                                let task_id = task.get("task_id").and_then(|v| v.as_str()).unwrap_or("?");
+                                    {
-                                let msg_model = task.get("model").and_then(|v| v.as_str()).unwrap_or("");
+                                        let mut st = tui_state.write().await;
-                                
+                                        st.status = "PAUSED".to_string();
-                                if !prompt.is_empty() && msg_model.starts_with("qwen-coder") {
+                                        st.push_log("Network", "Solmu siirretty taukotilaan".to_string(), None);
-
+                                    }
-                                    if let Some(ref mut engine) = llm {
+                                } else if cmd_str == "resume" {
-                                        busy = true;
+                                    tracing::info!("Jatketaan solmun suoritusta...");
-                                        tracing::info!("Generoidaan (task_id: {}): \"{}\"", task_id, prompt);
+                                    let req = json!({"type": "status_update", "status": "active"});
-
+                                    let _ = write.send(Message::Text(req.to_string())).await;
-                                        match engine.generate(prompt, 64) {
+                                    {
-                                            Ok(result) => {
+                                        let mut st = tui_state.write().await;
-                                                tracing::info!(
+                                        st.status = "ACTIVE".to_string();
-                                                    "Tulos: {} tokenia | {:.0}ms | {:.1} tok/s | \"{}\"",
+                                        st.push_log("System", "Suoritus jatkuu...".to_string(), None);
-                                                    result.tokens_generated,
-                                                    result.duration_ms,
-                                                    result.tokens_per_sec,
-                                                    &result.text[..result.text.len().min(80)]
-                                                );
-
-                                                let done = json!({
-                                                    "type": "llm_done",
-                                                    "prompt": prompt,
-                                                    "model": "Qwen2.5-Coder-0.5B (native/GPU)",
-                                                    "response": result.text,
-                                                    "tokens_generated": result.tokens_generated,
-                                                    "duration_ms": result.duration_ms,
-                                                    "tokens_per_sec": (result.tokens_per_sec * 10.0).round() / 10.0,
-                                                    "load_time_ms": 0,
-                                                    "task_id": task_id,
-                                                });
-                                                let _ = write.send(Message::Text(done.to_string())).await;
-                                            }
-                                            Err(e) => {
-                                                tracing::error!("Inferenssivirhe: {}", e);
-                                            }
-                                        }
-                                        busy = false;
                                     }
                                 }
                             }
                         }
-                        // Ohitetaan pair_task, stats jne.
+                        ws_msg = read.next() => {
+                            match ws_msg {
+                                Some(Ok(Message::Text(text))) => {
+                                    // Hubin control-viestit
+                                    if text.contains(r#""type":"control""#) {
+                                        if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
+                                            if let Some(action) = task.get("action").and_then(|v| v.as_str()) {
+                                                if action == "pause" {
+                                                    tracing::info!("Hub pakotti solmun tauolle (Pause)");
+                                                    let req = json!({"type": "status_update", "status": "paused"});
+                                                    let _ = write.send(Message::Text(req.to_string())).await;
+                                                    {
+                                                        let mut st = tui_state.write().await;
+                                                        st.status = "PAUSED".to_string();
+                                                        st.push_log("Network", "Hub kytki solmun tauolle".to_string(), None);
+                                                    }
+                                                } else if action == "resume" {
+                                                    tracing::info!("Hub aktivoi solmun suorituksen (Resume)");
+                                                    let req = json!({"type": "status_update", "status": "active"});
+                                                    let _ = write.send(Message::Text(req.to_string())).await;
+                                                    {
+                                                        let mut st = tui_state.write().await;
+                                                        st.status = "ACTIVE".to_string();
+                                                        st.push_log("Network", "Hub palautti solmun töihin".to_string(), None);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                    // Verkon globaali tila
+                                    if text.contains(r#""type":"network_status""#) {
+                                        if let Ok(status) = serde_json::from_str::<serde_json::Value>(&text) {
+                                            if let Some(nodes) = status.get("active_nodes").and_then(|v| v.as_u64()) {
+                                                if let Some(tasks) = status.get("tasks").and_then(|v| v.as_u64()) {
+                                                    let mut st = tui_state.write().await;
+                                                    st.network_active_nodes = nodes as usize;
+                                                    st.network_total_tasks = tasks;
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    // LLM-promptit
+                                    if text.contains("llm_prompt") {
+                                        if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
+                                            let prompt = task.get("prompt").and_then(|v| v.as_str()).unwrap_or("");
+                                            let task_id = task.get("task_id").and_then(|v| v.as_str()).unwrap_or("?");
+                                            let msg_model = task.get("model").and_then(|v| v.as_str()).unwrap_or("");
+
+                                            if !prompt.is_empty() && (msg_model.starts_with("qwen-coder") || msg_model.starts_with("qwen2.5-coder") || msg_model.starts_with("phi")) {
+                                                if let Some(ref engine) = llm {
+                                                    let max_tokens = task.get("max_tokens").and_then(|v| v.as_u64()).unwrap_or(1024) as usize;
+                                                    let prompt_lines = prompt.lines().count();
+                                                    let prompt_last: String = prompt.lines().last().unwrap_or("").chars().take(60).collect();
+                                                    tracing::info!("→ task_id:{} | {}r prompti | \"{}...\"", task_id, prompt_lines, prompt_last);
+                                                    {
+                                                        let mut st = tui_state.write().await;
+                                                        st.cur_task_id = Some(task_id.to_string());
+                                                        st.cur_prompt = Some(format!("→ {} riviä | \"{}...\"", prompt_lines, prompt_last));
+                                                        // Ei login puskemista vielä tässä! Yhdistetään se valmiin lohkoon yhdelle riville.
+                                                    }
+
+                                                    let model_name = engine.model_name();
+                                                    match engine.generate(prompt, max_tokens).await {
+                                                        Ok(result) => {
+                                                            let tokens_sec = (result.tokens_per_sec * 10.0).round() / 10.0;
+                                                            tracing::info!(
+                                                                "✓ {} | {} tok | {:.0}ms | {:.1} tok/s",
+                                                                model_name,
+                                                                result.tokens_generated,
+                                                                result.duration_ms,
+                                                                tokens_sec,
+                                                            );
+                                                            {
+                                                                let mut st = tui_state.write().await;
+                                                                st.tasks_completed += 1;
+                                                                st.last_tokens_sec = tokens_sec as f64;
+                                                                st.cur_task_id = None;
+                                                                st.cur_prompt = None;
+                                                                
+                                                                let msg_type = if task_id == "status-check" { "Ping" } else { "Task" };
+                                                                let msg_text = format!("{}  ({} tok)", task_id, result.tokens_generated);
+                                                                st.push_log(msg_type, msg_text, Some(tokens_sec as f64));
+                                                            }
+                                                            let prompt_short: String = prompt.lines().last().unwrap_or("").chars().take(100).collect();
+                                                            let done = json!({
+                                                                "type": "llm_done",
+                                                                "prompt": prompt_short,
+                                                                "model": format!("{} (Ollama)", model_name),
+                                                                "response": result.text,
+                                                                "tokens_generated": result.tokens_generated,
+                                                                "duration_ms": result.duration_ms,
+                                                                "tokens_per_sec": tokens_sec,
+                                                                "load_time_ms": 0,
+                                                                "task_id": task_id,
+                                                            });
+                                                            let _ = write.send(Message::Text(done.to_string())).await;
+                                                        }
+                                                        Err(e) => {
+                                                            tracing::error!("Inferenssivirhe: {}", e);
+                                                            {
+                                                                let mut st = tui_state.write().await;
+                                                                st.cur_task_id = None;
+                                                                st.cur_prompt = None;
+                                                                st.push_log("System", format!("Virhe inferenssissä: {}", e), None);
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    // Mallin vaihto lennossa
+                                    if text.contains("change_model") {
+                                        if let Ok(task) = serde_json::from_str::<serde_json::Value>(&text) {
+                                            if let Some(new_model) = task.get("model").and_then(|v| v.as_str()) {
+                                                if let Some(ref engine) = llm {
+                                                    tracing::info!("Vaihdetaan malli: {}", new_model);
+                                                    engine.set_model(new_model.to_string());
+                                                    match engine.ensure_model().await {
+                                                        Ok(()) => {
+                                                            tracing::info!("Malli {} valmis!", new_model);
+                                                            let mut st = tui_state.write().await;
+                                                            st.model_name = new_model.to_string();
+                                                            st.push_log("System", format!("Malli {} ladattu & valmis!", new_model), None);
+                                                        }
+                                                        Err(e) => tracing::error!("Mallin lataus epäonnistui: {}", e),
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                Some(Ok(_)) => {} // Muut viestityypit (binary/ping)
+                                Some(Err(_)) | None => break, // Yhteys poikki
+                            }
+                        }
                     }
                 }
+                
                 tracing::warn!("Yhteys hubiin katkesi — yritetään uudelleen 5s...");
             }
             Err(e) => {

network-poc/native-node/src/tui.rs

@@ -0,0 +1,67 @@
+use dialoguer::{Select, Input, theme::ColorfulTheme};
+use reqwest::Client;
+
+pub async fn select_model(ollama_url: &str, client: &Client) -> Result<String, String> {
+    // 1. Hae tagit
+    let mut models = vec![];
+    println!("  Haetaan asennettuja malleja osoitteesta {}...", ollama_url);
+    if let Ok(resp) = client.get(&format!("{}/api/tags", ollama_url)).send().await {
+        if resp.status().is_success() {
+            if let Ok(json) = resp.json::<serde_json::Value>().await {
+                if let Some(arr) = json.get("models").and_then(|v| v.as_array()) {
+                    for m in arr {
+                        if let Some(name) = m.get("name").and_then(|v| v.as_str()) {
+                            models.push(name.to_string());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    let download_opt = "[➕ Lataa uusi malli internetistä]";
+    let mut options = vec![download_opt.to_string()];
+    options.extend(models);
+
+    // 2. Kysy käyttäjältä Selectillä
+    let theme = ColorfulTheme::default();
+    let selection = Select::with_theme(&theme)
+        .with_prompt("Valitse Ollama-malli Kipinä-verkkoa varten:")
+        .default(if options.len() > 1 { 1 } else { 0 })
+        .items(&options)
+        .interact()
+        .map_err(|e| format!("TUI virhe: {}", e))?;
+
+    let selected = &options[selection];
+
+    // 3. Jos käyttäjä haluaa uuden, kysy nimeä
+    if selected == download_opt {
+        let new_model: String = Input::with_theme(&theme)
+            .with_prompt("Syötä ladattavan mallin nimi (esim. llama3 tai qwen2.5-coder:3b)")
+            .interact_text()
+            .map_err(|e| format!("TUI virhe: {}", e))?;
+        
+        let new_model = new_model.trim().to_string();
+        if new_model.is_empty() {
+            return Err("Mallin nimi ei voi olla tyhjä".to_string());
+        }
+        
+        println!("  Ladataan malleja taustalla... Tämä voi kestää hetken ({})", new_model);
+        // Odotetaan että pull on valmis
+        let pull_body = serde_json::json!({ "name": &new_model });
+        let resp = client.post(&format!("{}/api/pull", ollama_url))
+            .json(&pull_body)
+            .send()
+            .await
+            .map_err(|e| format!("Pull req virhe: {}", e))?;
+            
+        if resp.status().is_success() {
+            println!("  ✓ Malli {} ladattu onnistuneesti!", new_model);
+            return Ok(new_model);
+        } else {
+            return Err(format!("Ollama pull epäonnistui: {}", resp.status()));
+        }
+    }
+
+    Ok(selected.clone())
+}

network-poc/native-node/src/tui_dashboard.rs

@@ -0,0 +1,223 @@
+use crossterm::{
+    event::{self, Event, EventStream, KeyCode},
+    execute,
+    terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+};
+use ratatui::{
+    backend::CrosstermBackend,
+    layout::{Constraint, Direction, Layout, Alignment},
+    style::{Color, Modifier, Style},
+    widgets::{Block, Borders, Paragraph, Wrap},
+    Terminal,
+};
+use std::io;
+use tokio::sync::RwLock;
+use std::sync::Arc;
+use futures_util::StreamExt;
+use std::time::Duration;
+
+#[derive(Clone)]
+pub struct LogEntry {
+    pub ty: String,
+    pub msg: String,
+    pub speed: Option<f64>,
+}
+
+pub struct DashboardState {
+    pub logs: Vec<LogEntry>,
+    pub status: String,
+    pub node_id: Option<u64>,
+    pub sys_info: String,
+    pub model_name: String,
+    pub cur_task_id: Option<String>,
+    pub cur_prompt: Option<String>,
+    pub tasks_completed: u32,
+    pub last_tokens_sec: f64,
+    pub network_active_nodes: usize,
+    pub network_total_tasks: u64,
+}
+
+impl DashboardState {
+    pub fn new() -> Self {
+        Self {
+            logs: Vec::new(),
+            status: "ACTIVE".to_string(),
+            node_id: None,
+            sys_info: "".to_string(),
+            model_name: "Yhdistetään...".to_string(),
+            cur_task_id: None,
+            cur_prompt: None,
+            tasks_completed: 0,
+            last_tokens_sec: 0.0,
+            network_active_nodes: 1, // oletetaan itsemme
+            network_total_tasks: 0,
+        }
+    }
+
+    pub fn push_log(&mut self, ty: &str, msg: String, speed: Option<f64>) {
+        self.logs.push(LogEntry {
+            ty: ty.to_string(),
+            msg,
+            speed,
+        });
+        if self.logs.len() > 100 {
+            self.logs.remove(0);
+        }
+    }
+}
+
+pub async fn run_dashboard(
+    state: Arc<RwLock<DashboardState>>,
+    cmd_tx: tokio::sync::mpsc::UnboundedSender<String>,
+) -> Result<(), io::Error> {
+    enable_raw_mode()?;
+    let mut stdout = io::stdout();
+    execute!(stdout, EnterAlternateScreen)?;
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend)?;
+    terminal.clear()?;
+
+    let mut reader = EventStream::new();
+    let mut interval = tokio::time::interval(Duration::from_millis(100));
+
+    loop {
+        tokio::select! {
+            _ = interval.tick() => {
+                let st = state.read().await;
+                terminal.draw(|f| ui(f, &st))?;
+            }
+            ev = reader.next() => {
+                if let Some(Ok(Event::Key(key))) = ev {
+                    match key.code {
+                        KeyCode::Char('q') | KeyCode::Esc => {
+                            // Palautetaan näyttö ja suljetaan ohjelma
+                            disable_raw_mode()?;
+                            execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
+                            std::process::exit(0);
+                        }
+                        KeyCode::Char('p') | KeyCode::Char('P') => {
+                            let _ = cmd_tx.send("pause".to_string());
+                        }
+                        KeyCode::Char('r') | KeyCode::Char('R') | KeyCode::Char('s') => {
+                            let _ = cmd_tx.send("resume".to_string());
+                        }
+                        _ => {}
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub fn restore_terminal() {
+    let _ = disable_raw_mode();
+    let _ = execute!(io::stdout(), LeaveAlternateScreen);
+}
+
+fn ui(f: &mut ratatui::Frame, st: &DashboardState) {
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(3),  // Header
+            Constraint::Min(0),     // Body
+            Constraint::Length(3),  // Footer / Status
+        ].as_ref())
+        .split(f.area());
+
+    // --- Header ---
+    let header_text = match st.node_id {
+        Some(id) => format!(" Kipinä Agentic Node #{} ", id),
+        None => " Kipinä Agentic Node (Yhdistää...) ".to_string(),
+    };
+    let header = Paragraph::new(header_text)
+        .style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD))
+        .alignment(Alignment::Center)
+        .block(Block::default().borders(Borders::ALL).style(Style::default().fg(Color::DarkGray)));
+    f.render_widget(header, chunks[0]);
+
+    // --- Body ---
+    let body_chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Length(7), // Yläosan info ja tehtävä
+            Constraint::Min(0),    // Lokit / Chat alas
+        ].as_ref())
+        .split(chunks[1]);
+
+    let top_panels = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([
+            Constraint::Percentage(40), // Vasen paneeli (Info)
+            Constraint::Percentage(60), // Oikea paneeli (Tehtävä)
+        ].as_ref())
+        .split(body_chunks[0]);
+
+    // Vasen paneeli: Laitteisto, Malli & Verkosto
+    let info_text = format!(
+        "🚀 Malli: {}\n💻 Järjestelmä: {}\n📊 Tehdyt: {} | Nopeus: {} t/s\n🌐 Verkosto: {} solmua | {} tehtävää",
+        st.model_name, st.sys_info, st.tasks_completed, st.last_tokens_sec, st.network_active_nodes, st.network_total_tasks
+    );
+    let left_panel = Paragraph::new(info_text)
+        .block(Block::default().title(" Laitteisto ja AI ").borders(Borders::ALL))
+        .style(Style::default().fg(Color::White))
+        .wrap(Wrap { trim: true });
+    f.render_widget(left_panel, top_panels[0]);
+
+    // Oikea paneeli: Käynnissä oleva tehtävä
+    let task_title = match &st.cur_task_id {
+        Some(id) => format!(" Työn alla: {} ", id),
+        None => " Vapaana ".to_string(),
+    };
+    let task_content = st.cur_prompt.clone().unwrap_or_else(|| "Odotetaan tehtäviä Hubilta...".to_string());
+    
+    let task_style = if st.cur_task_id.is_some() {
+        Style::default().fg(Color::Magenta)
+    } else {
+        Style::default().fg(Color::DarkGray)
+    };
+    
+    let task_panel = Paragraph::new(task_content)
+        .wrap(Wrap { trim: true })
+        .block(Block::default().title(task_title).borders(Borders::ALL).style(task_style));
+    f.render_widget(task_panel, top_panels[1]);
+
+    // Alaosan paneeli: Tapahtumaloki koko leveydeltä
+    let area_height = body_chunks[1].height.saturating_sub(2) as usize;
+    let skip_count = if st.logs.len() > area_height { st.logs.len() - area_height } else { 0 };
+    
+    let visible_logs: Vec<ratatui::text::Line> = st.logs.iter().skip(skip_count).map(|log| {
+        let ty_color = match log.ty.as_str() {
+            "System" => Color::Yellow,
+            "Network" => Color::Blue,
+            "Task" => Color::Magenta,
+            "Ping" => Color::DarkGray,
+            _ => Color::White,
+        };
+        
+        let speed_str = if let Some(s) = log.speed {
+            format!(" | {:.1} tok/s", s)
+        } else {
+            "".to_string()
+        };
+        
+        ratatui::text::Line::from(vec![
+            ratatui::text::Span::styled(format!("{: <8}", log.ty), Style::default().fg(ty_color).add_modifier(Modifier::BOLD)),
+            ratatui::text::Span::raw(" | "),
+            ratatui::text::Span::styled(log.msg.clone(), Style::default().fg(Color::White)),
+            ratatui::text::Span::styled(speed_str, Style::default().fg(ty_color)),
+        ])
+    }).collect();
+
+    let logs_panel = Paragraph::new(visible_logs)
+        .block(Block::default().title(" Tapahtumaloki ").borders(Borders::ALL).style(Style::default().fg(Color::Cyan)));
+    f.render_widget(logs_panel, body_chunks[1]);
+
+    // --- Footer / Status ---
+    let status_color = if st.status == "ACTIVE" { Color::Green } else { Color::Yellow };
+    let status_text = format!(" Tila: {} | Komennot: [P] Pause / [R] Työhön / [Q] Sulje ", st.status);
+    let footer = Paragraph::new(status_text)
+        .style(Style::default().fg(status_color).add_modifier(Modifier::BOLD))
+        .alignment(Alignment::Center)
+        .block(Block::default().borders(Borders::ALL));
+    f.render_widget(footer, chunks[2]);
+}

network-poc/node/src/lib.rs

@@ -38,17 +38,50 @@ pub fn set_gpu_load(load: u32) {
     console_log!("[Wasm] GPU Kuormitusraja vaihdettu -> {}%", load);
 }
 
-// Asynkroninen odotus WebAssemblylle
+// Worker-yhteensopiva setTimeout — toimii sekä Window- että Worker-kontekstissa
-async fn sleep_ms(ms: i32) {
+#[wasm_bindgen]
+extern "C" {
+    #[wasm_bindgen(js_name = setTimeout)]
+    fn set_timeout(closure: &js_sys::Function, ms: i32);
+}
+
+// Asynkroninen odotus WebAssemblylle (Window + Worker)
+pub async fn sleep_ms(ms: i32) {
     let promise = js_sys::Promise::new(&mut |resolve, _| {
-        web_sys::window()
+        set_timeout(&resolve, ms);
-            .unwrap()
-            .set_timeout_with_callback_and_timeout_and_arguments_0(&resolve, ms)
-            .unwrap();
     });
     let _ = wasm_bindgen_futures::JsFuture::from(promise).await;
 }
 
+// Worker-yhteensopiva Performance — käyttää globalThis.performance
+pub fn perf_now() -> f64 {
+    js_sys::Reflect::get(&js_sys::global(), &"performance".into())
+        .ok()
+        .and_then(|p| js_sys::Reflect::get(&p, &"now".into()).ok())
+        .and_then(|f| f.dyn_into::<js_sys::Function>().ok())
+        .and_then(|f| {
+            let perf = js_sys::Reflect::get(&js_sys::global(), &"performance".into()).unwrap();
+            f.call0(&perf).ok()
+        })
+        .and_then(|v| v.as_f64())
+        .unwrap_or(0.0)
+}
+
+// Worker-yhteensopiva fetch — käyttää globalThis.fetch
+pub async fn worker_fetch(url: &str) -> Result<web_sys::Response, String> {
+    let promise = js_sys::Reflect::get(&js_sys::global(), &"fetch".into())
+        .map_err(|_| "fetch ei saatavilla".to_string())?
+        .dyn_into::<js_sys::Function>()
+        .map_err(|_| "fetch ei funktio".to_string())?
+        .call1(&JsValue::NULL, &url.into())
+        .map_err(|e| format!("fetch: {:?}", e))?;
+    let resp = wasm_bindgen_futures::JsFuture::from(js_sys::Promise::from(promise))
+        .await
+        .map_err(|e| format!("fetch await: {:?}", e))?;
+    resp.dyn_into::<web_sys::Response>()
+        .map_err(|_| "ei Response".to_string())
+}
+
 // Geneerinen tensorilaskenta — toimii millä tahansa Burn-backendillä
 fn run_matmul<B: burn::tensor::backend::Backend>(size: usize) -> String {
     let device = Default::default();
@@ -85,6 +118,27 @@ async fn run_ai_tensor_inference(difficulty: usize) -> String {
     format!("PoC {} Matmul ({}x{}) >> {}", backend_name, active_workload_size, active_workload_size, result)
 }
 
+/// JS-exportti: tokenisoi tekstin ja palauttaa JSON-merkkijonon
+/// Tokenizer ladataan IndexedDB:stä (täytyy olla ladattu aiemmin)
+#[wasm_bindgen]
+pub async fn tokenize_js(text: String) -> Result<String, JsValue> {
+    let cached_tok = storage::load_from_idb("tokenizer.json").await.unwrap_or(None);
+    let Some(bytes) = cached_tok else {
+        // Yritetään ladata verkosta
+        let resp = reqwest::get("https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B/resolve/main/tokenizer.json").await
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-lataus epäonnistui: {}", e)))?;
+        let bytes = resp.bytes().await
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-lataus epäonnistui: {}", e)))?;
+        let _ = storage::save_to_idb("tokenizer.json", &bytes).await;
+        let tokenizer = tokenizers::Tokenizer::from_bytes(&bytes)
+            .map_err(|e| JsValue::from_str(&format!("Tokenizer-parsinta: {}", e)))?;
+        return Ok(tokenize_text(&tokenizer, &text).to_string());
+    };
+    let tokenizer = tokenizers::Tokenizer::from_bytes(&bytes)
+        .map_err(|e| JsValue::from_str(&format!("Tokenizer-parsinta: {}", e)))?;
+    Ok(tokenize_text(&tokenizer, &text).to_string())
+}
+
 /// Tokenisoi yhden tekstin ja palauttaa metriikat
 fn tokenize_text(tokenizer: &tokenizers::Tokenizer, text: &str) -> serde_json::Value {
     let char_count = text.chars().count();
@@ -123,10 +177,9 @@ async fn run_single_tokenize(text: String, ws: Rc<RefCell<WebSocket>>) {
     let Some(bytes) = cached_tok else { return; };
     let Ok(tokenizer) = tokenizers::Tokenizer::from_bytes(&bytes) else { return; };
 
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    let start = perf_now();
-    let start = perf.now();
     let result = tokenize_text(&tokenizer, &text);
-    let duration_ms = perf.now() - start;
+    let duration_ms = perf_now() - start;
 
     let token_count = result["token_count"].as_u64().unwrap_or(0);
     let cpt = result["chars_per_token"].as_f64().unwrap_or(0.0);
@@ -157,11 +210,10 @@ async fn run_pair_comparison(en_text: String, fi_text: String, ws: Rc<RefCell<We
         return;
     };
 
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    let start_time = perf_now();
-    let start_time = perf.now();
     let en_result = tokenize_text(&tokenizer, &en_text);
     let fi_result = tokenize_text(&tokenizer, &fi_text);
-    let duration_ms = perf.now() - start_time; // millisekunteja desimaalitarkkuudella
+    let duration_ms = perf_now() - start_time;
 
     let en_cpt = en_result["chars_per_token"].as_f64().unwrap_or(0.0);
     let fi_cpt = fi_result["chars_per_token"].as_f64().unwrap_or(0.0);
@@ -296,7 +348,9 @@ pub async fn start_agent_node(hub_url: String, has_webgpu: bool, device_info_jso
                         });
                     }
                 }
-            } else if msg.contains("llm_prompt") && (current_task == 4 || current_task == 5) {
+            } else if msg.contains("llm_prompt") {
+                console_log!("[DEBUG] llm_prompt vastaanotettu! current_task={}, busy={}", current_task, LLM_BUSY.load(Ordering::SeqCst));
+                if current_task == 4 || current_task == 5 {
                 // Qwen2.5-Coder: 4 = 0.5B, 5 = 3B
                 if let Ok(task) = serde_json::from_str::<serde_json::Value>(&msg) {
                     let prompt = task.get("prompt").and_then(|v| v.as_str()).unwrap_or("").to_string();
@@ -324,6 +378,7 @@ pub async fn start_agent_node(hub_url: String, has_webgpu: bool, device_info_jso
                         }
                     }
                 }
+                } // current_task == 4 || 5
             } else if msg.contains("ai_task") {
                 console_log!("Hub task vastaanotettu, ajetaan GPU:lla...");
                 let ws_for_async = ws_clone.clone();

network-poc/node/src/qwen.rs

@@ -24,10 +24,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 
     console_log!("[Qwen] Ladataan {}...", key);
 
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch epäonnistui: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response".to_string())?;
     if !resp.ok() { return Err(format!("HTTP {}", resp.status())); }
 
     let total_size: usize = resp.headers()
@@ -71,7 +68,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 }
 
 pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    // performance via crate::perf_now()
 
     let tok_bytes = match ensure_cached("qwen05b-tokenizer.json", TOKENIZER_URL, &ws).await {
         Ok(b) => b,
@@ -88,7 +85,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     };
 
     console_log!("[Qwen] Rakennetaan mallia...");
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
     let device = Device::Cpu;
     let dtype = DType::F32;
 
@@ -120,7 +117,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
         Err(e) => { console_log!("[Qwen] Mallin lataus: {}", e); return; }
     };
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     console_log!("[Qwen] Malli ladattu ({:.0}ms). Generoidaan...", load_time);
 
     let encoding = match tokenizer.encode(prompt.as_str(), true) {
@@ -131,7 +128,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     let input_len = input_ids.len();
     console_log!("[Qwen] Syöte: {} tokenia", input_len);
 
-    let start_gen = perf.now();
+    let start_gen = crate::perf_now();
     let max_new_tokens = 32;
     let mut generated_text = String::new();
     let mut tokens_generated: usize = 0;
@@ -202,7 +199,7 @@ pub async fn run_qwen_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
         crate::sleep_ms(0).await;
     }
 
-    let gen_time = perf.now() - start_gen;
+    let gen_time = crate::perf_now() - start_gen;
     let tokens_per_sec = if gen_time > 0.0 { (tokens_generated as f64 / gen_time) * 1000.0 } else { 0.0 };
     console_log!("[Qwen] {} tokenia | {:.0}ms | {:.1} tok/s", tokens_generated, gen_time, tokens_per_sec);
 

network-poc/node/src/qwen_coder.rs

@@ -140,10 +140,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
 
     console_log!("[Coder] Ladataan {}...", key);
 
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response".to_string())?;
     if !resp.ok() { return Err(format!("HTTP {}", resp.status())); }
 
     let total_size: usize = resp.headers()
@@ -251,17 +248,19 @@ async fn get_or_build_model(use_3b: bool, ws: &Rc<RefCell<WebSocket>>) -> Result
 
 /// use_3b: false = 0.5B (nopea), true = 3B (laadukas)
 pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use_3b: bool, task_id: Option<String>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    console_log!("[Coder] run_coder_inference alkaa! prompt={}", &prompt[..prompt.len().min(50)]);
     let size_label = if use_3b { "3B" } else { "0.5B" };
 
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
 
+    console_log!("[Coder] Kutsutaan get_or_build_model...");
     if let Err(e) = get_or_build_model(use_3b, &ws).await {
-        console_log!("[Coder] Mallin lataus: {}", e);
+        console_log!("[Coder] Mallin lataus epäonnistui: {}", e);
         return;
     }
+    console_log!("[Coder] Malli valmis, aloitetaan inferenssi");
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     if load_time > 100.0 {
         console_log!("[Coder] Malli ladattu ({:.0}ms). Generoidaan...", load_time);
     }
@@ -297,7 +296,7 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
         console_log!("[Coder] Syöte: {} tokenia", input_len);
 
         let device = Device::Cpu;
-        let start_gen = perf.now();
+        let start_gen = crate::perf_now();
         let eos_token = 151645u32;
         let temperature: f32 = 0.7;
         let top_k: usize = 40;
@@ -324,7 +323,11 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
             if let Ok(text) = cached.tokenizer.decode(&[next_token], true) {
                 generated_text.push_str(&text);
                 let mut chunk = serde_json::json!({ "type": "llm_chunk", "token": text, "prompt": prompt, "model": "Qwen2.5-Coder" });
-                if let Some(ref tid) = task_id { chunk.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid)); }
+                if let Some(ref tid) = task_id { 
+                    if let Some(obj) = chunk.as_object_mut() {
+                        obj.insert("task_id".to_string(), serde_json::json!(tid)); 
+                    }
+                }
                 let _ = ws.borrow().send_with_str(&chunk.to_string());
             }
             all_generated.push(next_token);
@@ -366,14 +369,18 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
                 }
 
                 let mut chunk = serde_json::json!({ "type": "llm_chunk", "token": text, "prompt": prompt, "model": "Qwen2.5-Coder" });
-                if let Some(ref tid) = task_id { chunk.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid)); }
+                if let Some(ref tid) = task_id { 
+                    if let Some(obj) = chunk.as_object_mut() {
+                        obj.insert("task_id".to_string(), serde_json::json!(tid));
+                    }
+                }
                 let _ = ws.borrow().send_with_str(&chunk.to_string());
             }
             all_generated.push(next_token);
             tokens_generated += 1;
         }
 
-        let gen_time = perf.now() - start_gen;
+        let gen_time = crate::perf_now() - start_gen;
 
         // Siivotaan vastaus: poista markdown-koodiblokit ja johdantotekstit
         let cleaned = strip_markdown_wrapper(&generated_text);
@@ -395,7 +402,9 @@ pub async fn run_coder_inference(prompt: String, ws: Rc<RefCell<WebSocket>>, use
         "load_time_ms": (load_time * 100.0).round() / 100.0,
     });
     if let Some(tid) = task_id {
-        done.as_object_mut().unwrap().insert("task_id".to_string(), serde_json::json!(tid));
+        if let Some(obj) = done.as_object_mut() {
+            obj.insert("task_id".to_string(), serde_json::json!(tid));
+        }
     }
     let _ = ws.borrow().send_with_str(&done.to_string());
 }

network-poc/node/src/smollm.rs

@@ -28,10 +28,7 @@ async fn ensure_cached(key: &str, url: &str, ws: &Rc<RefCell<WebSocket>>) -> Res
     send_progress(ws, key, 0, 0, 0);
 
     // Fetch API:lla saadaan Content-Length ja streaming-luku
-    let window = web_sys::window().unwrap();
+    let resp = crate::worker_fetch(url).await?;
-    let resp_val = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url))
-        .await.map_err(|e| format!("Fetch epäonnistui: {:?}", e))?;
-    let resp: web_sys::Response = resp_val.dyn_into().map_err(|_| "Ei Response-objekti".to_string())?;
 
     if !resp.ok() {
         return Err(format!("HTTP {}", resp.status()));
@@ -99,7 +96,7 @@ fn send_progress(ws: &Rc<RefCell<WebSocket>>, file: &str, pct: u32, loaded: usiz
 
 /// Lataa malli ja tokenizer, suorita inferenssi ja streamaa tokenit hubille
 pub async fn run_smollm_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
-    let perf = web_sys::window().unwrap().performance().unwrap();
+    // performance via crate::perf_now()
 
     // 1. Lataa tokenizer
     let tok_bytes = match ensure_cached("smollm-tokenizer.json", TOKENIZER_URL, &ws).await {
@@ -122,7 +119,7 @@ pub async fn run_smollm_inference(prompt: String, ws: Rc<RefCell<WebSocket>>) {
     // Burn 0.21-pre.2 cubecl-runtime ei käänny Wasmille (println! puuttuu)
     // → NdArray kunnes Burn 0.21 stable + Wasm-tuki
     console_log!("[SmolLM] Burn NdArray (CPU) inferenssi...");
-    run_burn_inference::<burn::backend::NdArray>(prompt, model_bytes, tokenizer, ws, perf.clone()).await;
+    run_burn_inference::<burn::backend::NdArray>(prompt, model_bytes, tokenizer, ws).await;
 }
 
 async fn run_burn_inference<B: burn::tensor::backend::Backend>(
@@ -130,9 +127,8 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
     model_bytes: Vec<u8>,
     tokenizer: tokenizers::Tokenizer,
     ws: Rc<RefCell<WebSocket>>,
-    perf: web_sys::Performance, // Korjattu Wasm-performanssi välitettäväksi
 ) {
-    let start_load = perf.now();
+    let start_load = crate::perf_now();
 
     let device = Default::default();
     let config = crate::burn_smollm::config::SmolLMConfig::default();
@@ -143,7 +139,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
         Err(e) => { console_log!("[SmolLM] Lataus epäonnistui: {}", e); return; }
     };
 
-    let load_time = perf.now() - start_load;
+    let load_time = crate::perf_now() - start_load;
     console_log!("[SmolLM] Burn-malli ladattu ({:.0}ms). Generoidaan...", load_time);
 
     let formatted_prompt = format!("<|im_start|>user\n{}<|im_end|>\n<|im_start|>assistant\n", prompt);
@@ -156,7 +152,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
     let input_len = input_ids.len();
     console_log!("[SmolLM] Syöte: {} tokenia", input_len);
 
-    let start_gen = perf.now();
+    let start_gen = crate::perf_now();
     let max_new_tokens = 32;
     let mut generated_text = String::new();
     let mut tokens_generated: usize = 0;
@@ -219,7 +215,7 @@ async fn run_burn_inference<B: burn::tensor::backend::Backend>(
         tokens_generated += 1;
     }
 
-    let gen_time = perf.now() - start_gen;
+    let gen_time = crate::perf_now() - start_gen;
     let tokens_per_sec = if gen_time > 0.0 { (tokens_generated as f64 / gen_time) * 1000.0 } else { 0.0 };
 
     let done = serde_json::json!({

network-poc/start-local.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# Kipinä Agentic Network lokaali pikatesti
+# Tämä ohjelma käynnistää lokaalin Kipinä Hubin taustalle, ja heittää sen jälkeen näkyviin
+# visuaalisen Natiivisolmun Ratatui-ruudun yhdistäen sen automaattisesti siihen.
+# Kun poistut Ratatui-näytöstä (esim painamalla Q), niin skripti sammuttaa siististi
+# myös taustalla pyörivän lokaalin Hubin!
+
+cd "$(dirname "$0")"
+
+echo "========================================="
+echo " 🔥  Kipinä Agentic Network - Local Run  🔥"
+echo "========================================="
+echo "Varmistetaan portin 3000 vapaus..."
+lsof -ti :3000 | xargs kill -9 2>/dev/null || true
+
+echo ""
+echo "Käynnistetään Kipinä Hub taustalle..."
+# Ohjataan Hubin logit erilliseen tiedostoon jottei se sotke näkymää!
+env STATIC_DIR=frontend/dist cargo run -p hub > hub-local.log 2>&1 &
+HUB_PID=$!
+
+# Odotellaan, että Hub saa portit kuunteluun
+sleep 2
+
+echo "Käynnistetään Natiivisolmu ja Ratatui-dashboard..."
+# Käynnistetään TUI ja pakotetaan yhdistämään lokaaliin Hubiin.
+env -u OLLAMA_MODEL HUB_URL=ws://127.0.0.1:3000/ws cargo run -p native-node
+
+# Kun TUI ohjelmasta on poistuttu
+echo ""
+echo "Dashboard suljettu! Ajetaan lokaali Hub (#$HUB_PID) siististi alas..."
+kill $HUB_PID
+echo "Kaikki sammutettu. Kiitos!"

network-poc/target-check/.rustc_info.json

@@ -0,0 +1 @@
+{"rustc_fingerprint":15841952146704291179,"outputs":{"17747080675513052775":{"success":true,"status":"","code":0,"stdout":"rustc 1.94.1 (e408947bf 2026-03-25)\nbinary: rustc\ncommit-hash: e408947bfd200af42db322daf0fadfe7e26d3bd1\ncommit-date: 2026-03-25\nhost: x86_64-unknown-linux-gnu\nrelease: 1.94.1\nLLVM version: 21.1.8\n","stderr":""},"7971740275564407648":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/jaakko/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}

network-poc/target-check/CACHEDIR.TAG

@@ -0,0 +1,3 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by cargo.
+# For information about cache directory tags see https://bford.info/cachedir/

network-poc/temp/frontend-old/.gitignore

@@ -0,0 +1,24 @@
+# build output
+dist/
+# generated types
+.astro/
+
+# dependencies
+node_modules/
+
+# logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+
+# environment variables
+.env
+.env.production
+
+# macOS-specific files
+.DS_Store
+
+# jetbrains setting folder
+.idea/

network-poc/temp/frontend-old/.vscode/extensions.json

@@ -0,0 +1,4 @@
+{
+  "recommendations": ["astro-build.astro-vscode"],
+  "unwantedRecommendations": []
+}

network-poc/temp/frontend-old/.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "./node_modules/.bin/astro dev",
+      "name": "Development server",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

network-poc/temp/frontend-old/README.md

@@ -0,0 +1,43 @@
+# Astro Starter Kit: Minimal
+
+```sh
+npm create astro@latest -- --template minimal
+```
+
+> 🧑‍🚀 **Seasoned astronaut?** Delete this file. Have fun!
+
+## 🚀 Project Structure
+
+Inside of your Astro project, you'll see the following folders and files:
+
+```text
+/
+├── public/
+├── src/
+│   └── pages/
+│       └── index.astro
+└── package.json
+```
+
+Astro looks for `.astro` or `.md` files in the `src/pages/` directory. Each page is exposed as a route based on its file name.
+
+There's nothing special about `src/components/`, but that's where we like to put any Astro/React/Vue/Svelte/Preact components.
+
+Any static assets, like images, can be placed in the `public/` directory.
+
+## 🧞 Commands
+
+All commands are run from the root of the project, from a terminal:
+
+| Command                   | Action                                           |
+| :------------------------ | :----------------------------------------------- |
+| `npm install`             | Installs dependencies                            |
+| `npm run dev`             | Starts local dev server at `localhost:4321`      |
+| `npm run build`           | Build your production site to `./dist/`          |
+| `npm run preview`         | Preview your build locally, before deploying     |
+| `npm run astro ...`       | Run CLI commands like `astro add`, `astro check` |
+| `npm run astro -- --help` | Get help using the Astro CLI                     |
+
+## 👀 Want to learn more?
+
+Feel free to check [our documentation](https://docs.astro.build) or jump into our [Discord server](https://astro.build/chat).

network-poc/temp/frontend-old/astro.config.mjs

@@ -0,0 +1,5 @@
+// @ts-check
+import { defineConfig } from 'astro/config';
+
+// https://astro.build/config
+export default defineConfig({});

network-poc/temp/frontend-old/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "frontend",
+  "type": "module",
+  "version": "0.0.1",
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "dev": "astro dev",
+    "build": "astro build",
+    "preview": "astro preview",
+    "astro": "astro"
+  },
+  "dependencies": {
+    "astro": "^6.1.5",
+    "three": "^0.183.2"
+  }
+}

network-poc/temp/frontend-old/public/avatars/README.md

@@ -0,0 +1,34 @@
+# Kipinä Agentic Playground - Animaatioiden käyttöönotto
+
+Koska Kipinä-verkon agenttien avatarit tällä erää ovat staattisia PNG-kuvatiedostoja, käyttöliittymä hyödyntää CSS-pohjaista pomppimisilmiötä (sekä pulppuavaa 💬 puhekuplaa) "puhumisen" merkkinä. Olemme kuitenkin koodanneet taustalle piilotetun tuen aivioiduille videoloopeille myöhempää käyttöä varten!
+
+Näin saat UI:n tukemaan oikeasti animoituja kasvoja/videoita.
+
+## 1. Luo Animoidut GIF-tiedostot
+Valitse mikä tahansa ulkoinen AI-työkalu (kuten HeyGen, Pika v1.0, tai Midjourney+Runway yhdistelmä) ja muunna avatar-kuvat (esim. `kettu_notext.png`) 3-5 sekunnin kestäviksi GIF-loopeiksi. Hahmon leuka tulisi pyöriä tai naama vääntyillä puhuessaan.
+
+## 2. Nimeä Tiedostot Oikein ja Lisää Ne Kansioon
+Siirrä uudet GIF-animaatiot samaan kansioon alkuperäisten kuvien kanssa. Muuta niiden nimi siten, että se päättyy tunnisteeseen `_puhuva.gif`.
+
+Esimerkkejä:
+- Koodari `kipina_notext.png` → `kipina_notext_puhuva.gif`
+- Manageri `karhunpentu.png` → `karhunpentu_puhuva.gif`
+- Asiakas `kettu_notext.png` → `kettu_notext_puhuva.gif`
+
+## 3. Aktivoi Koodi
+Käännä Kipinä Playground -ohjaimen JavaScript-koodista piilotettu ominaisuus päälle.
+
+Etsi tiedostosta `../index.html` (noin riviltä 1084, `updatePromptEditor`-funktiosta):
+```javascript
+// Piilotettu ominaisuus: Puhuvien videoiden / gif-animaatioiden kytkentä
+window.USE_ANIMATED_GIFS = false;
+```
+Muuta tuo `false` arvoon `true`:
+```javascript
+window.USE_ANIMATED_GIFS = true;
+```
+
+**Mitä logiikka tekee?**
+Aina kun valitset agentin kaaviosta, koodi korvaa aktiivisen kuvakkeen lopussa olevan `.png` -päätteen sanalla `_puhuva.gif` – lennosta! Jos poistut agentin valinnasta tai valitset jonkun toisen, koodi vaihtaa kuvan välittömästi takaisin staattiseen `.png`-versioon ja sulkee ilmentymän suun.
+
+Näin saat kaikkien asiantuntijoiden face-track looppeja hallittua yhdellä kädenkäänteellä.