GitHub Actions deploy 58536f00fab443e850da1235c8acd1c4f10ce306

Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim-bookworm
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PYTHONPATH=/workspace
+
+WORKDIR /workspace
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY core-python/requirements.txt /workspace/core-python/requirements.txt
+RUN python3 -m pip install -r /workspace/core-python/requirements.txt
+
+COPY core-python /workspace/core-python
+COPY huggingface_human_training_space /workspace/huggingface_human_training_space
+
+RUN python3 -m pip install -e /workspace/core-python --no-deps
+
+EXPOSE 7860
+
+CMD ["python3", "-m", "uvicorn", "--app-dir", "/workspace", "huggingface_human_training_space.app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,70 @@
 ---
-title: Maris.ai.human.training
-emoji: 🔥
+title: Maris AI Human Training
+emoji: 🎓
 colorFrom: indigo
-colorTo: gray
-sdk: gradio
-sdk_version: 6.13.0
-app_file: app.py
-pinned: false
+colorTo: blue
+sdk: docker
+app_port: 7860
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Maris AI Human Training Space
+
+Atsevišķs Hugging Face Space priekš `MarisUK/maris.ai.human.training` ar profesionālu sākuma lapu, login/register plūsmu, lomām un skaidru dokumentāciju.
+
+## Ko Space nodrošina
+
+- atsevišķu Space no `MarisUK/maris.ai.agent`;
+- starta lapu ar Maris AI logo, nosaukumu un skaidru ieeju komandai;
+- `login` un `register` plūsmu;
+- lomu izvēli: `owner`, `secretary`, `trainee`, `user`;
+- profesionālu onboarding, workflow aprakstu, piemēru bibliotēku un dokumentācijas sadaļu;
+- lokālu lietotāju glabātuvi persistent storage failā, izmantojot hashētu paroli.
+- profesionālu human training builder ar atsevišķiem laukiem:
+  - `model_name`
+  - `hub_model_id`
+  - `continue_model_path`
+  - `continue_from_latest_artefact`
+  - `output_subdir`
+  - `num_epochs`
+  - `push_to_hub`
+  - `all_branches`
+- staging preview, artefaktu publicēšanu dataset repozitorijā un reālu treniņa startu no šī Space.
+
+## Lomu nozīme
+
+- **owner** — nosaka mērķus, riskus un gala apstiprinājumu;
+- **secretary** — strukturē ievadi, dokumentāciju un komandas plūsmu;
+- **trainee** — veido un pārskata mācību piemērus;
+- **user** — sniedz reālus scenārijus un kvalitātes feedback.
+
+## Svarīgie faili bundle publicēšanai
+
+```text
+huggingface_human_training_space/
+core-python/
+```
+
+## Publicēšana no šī repozitorija
+
+```bash
+MARIS_HUMAN_TRAINING_SPACE_REPO=MarisUK/maris.ai.human.training bash ./huggingface/sync.sh upload-human-training-space
+```
+
+## GitHub Actions
+
+Šim Space paredzēts atsevišķs workflow:
+
+```text
+.github/workflows/hf-human-training-space-deploy.yml
+```
+
+## Lai Space sāktu reāli strādāt
+
+Nepieciešams:
+
+1. Hugging Face Space secrets ar publish tokenu (`HF_TOKEN` vai `MARIS_TOKEN`);
+2. persistent storage, lai saglabātu lietotājus, staging artefaktus un lokālos checkpointus;
+3. dataset repo, kur publicēt human training artefaktus;
+4. model repo, piemēram, `MarisUK/maris-ai-lv`, kur publicēt treniņa rezultātu;
+5. GPU-capable Space runtime, ja gribi reāli trenēt modeli šajā Space vidē.

core-python/.env.example

@@ -0,0 +1,73 @@
+# Core Python vides mainīgie
+
+# Maris publicēšana un treniņš
+MARIS_REPO_TOKEN=your_maris_repo_token_here
+# Neobligāti Hugging Face standarta token aliasi privātiem/custom repo Railway vidē
+# HF_TOKEN=your_huggingface_token_here
+# HUGGING_FACE_HUB_TOKEN=your_huggingface_token_here
+# HUGGINGFACEHUB_API_TOKEN=your_huggingface_token_here
+MARIS_MEMORY_REPO=MarisUK/maris-ai-memory
+MARIS_MODEL_REPO=MarisUK/maris-ai-master
+MARIS_AGENT_SPACE_REPO=MarisUK/maris.ai.agent
+MARIS_HUMAN_TRAINING_SPACE_REPO=MarisUK/maris.ai.human.training
+MARIS_AGENT_MODEL=MarisUK/maris-ai-master
+# Papildu aģenta fallback modeļi, kurus Space var izmantot, ja primārais modelis neatbild
+MARIS_AGENT_FALLBACK_MODELS=Qwen/Qwen3-Coder-480B-A35B-Instruct
+# Neobligāti UI dropdown modeļi aģentam
+# MARIS_AGENT_MODELS=Qwen/Qwen3-Coder-480B-A35B-Instruct,Qwen/Qwen3-880B-Instruct
+MARIS_TRAIN_CONFIG_PATH=../huggingface/training-config.json
+MARIS_TRAIN_MODEL_PRESET=balanced
+# Neobligāti papildu training preset'i lieliem ārējiem modeļiem (JSON formātā vai owner/name sarakstā)
+# MARIS_TRAIN_EXTRA_MODELS={"qwen-880b":{"model_name":"Qwen/Qwen3-880B-Instruct","label":"Qwen ultra preset","description":"Liels ārējs preset 880B klases modeļiem."}}
+# MARIS_TRAIN_EXTRA_MODELS=Qwen/Qwen3-Coder-480B-A35B-Instruct,coder-7b=Qwen/Qwen2.5-7B-Instruct
+MARIS_TRAIN_OUTPUT_DIR=./output/model
+MARIS_TRAIN_PUBLISH=false
+MARIS_TRAIN_SCORING_ENABLED=true
+MARIS_TRAIN_WEIGHTED_REPETITION_ENABLED=true
+MARIS_TRAIN_MEDIUM_SCORE_REPEAT_COUNT=2
+MARIS_TRAIN_HIGH_SCORE_REPEAT_COUNT=3
+MARIS_TRAIN_SOURCE_WEIGHTING_ENABLED=true
+# MARIS_TRAIN_SOURCE_WEIGHT_MAP={"production":1.3,"synthetic":1.0,"noisy":0.65,"unknown":1.0}
+MARIS_TRAIN_MAX_EFFECTIVE_REPEAT_COUNT=6
+MARIS_TRAIN_BENCHMARK_FEEDBACK_ENABLED=true
+MARIS_TRAIN_BENCHMARK_FEEDBACK_AUTO_DISCOVER=true
+# MARIS_TRAIN_BENCHMARK_FEEDBACK_PATH=./output/previous-run/benchmark-feedback.json
+MARIS_TRAIN_BENCHMARK_FEEDBACK_BOOST_SCALE=2.0
+MARIS_TRAIN_BENCHMARK_FEEDBACK_MAX_MULTIPLIER=1.75
+# Persistent treniņiem: turpini no pēdējā lokālā artefakta
+# MARIS_TRAIN_CONTINUE_FROM_LATEST=true
+# MARIS_TRAIN_CONTINUE_MODEL_PATH=./output/model
+
+# Specialist modeļi (norādi tikai Maris AI modeļus; pārraksti tikai, ja vajag citu repo)
+# Galvenais frontend čata /chat modelis
+TEXT_MODEL=MarisUK/maris-ai-text
+# Railway/runtime override galvenajam čatam ar jebkuru Hugging Face modeli
+# MARIS_RUNTIME_TEXT_MODEL=Qwen/Qwen2.5-7B-Instruct
+IMAGE_MODEL=MarisUK/maris-ai-image
+MUSIC_MODEL=MarisUK/maris-ai-music
+TTS_MODEL=MarisUK/maris-tts-runtime
+STT_MODEL=MarisUK/maris-stt-runtime
+VIDEO_MODEL=MarisUK/maris-ai-video
+# Railway runtime tagad pieņem arī jebkuru citu owner/name Hugging Face repo visiem augstāk minētajiem modeļiem
+# IMAGE_MODEL=stabilityai/stable-diffusion-2-1
+# MUSIC_MODEL=facebook/musicgen-small
+# TTS_MODEL=microsoft/speecht5_tts
+# STT_MODEL=openai/whisper-small
+# VIDEO_MODEL=THUDM/CogVideoX-2b
+
+# LiveKit realtime voice assistant
+LIVEKIT_URL=wss://your-livekit-host
+LIVEKIT_API_KEY=your_livekit_key
+LIVEKIT_API_SECRET=your_livekit_secret
+MARIS_LIVEKIT_ROOM_PREFIX=maris-voice
+MARIS_LIVEKIT_AGENT_NAME=maris-livekit-agent
+MARIS_VOICE_STT_PROVIDER=speechmatics
+MARIS_VOICE_LLM_PROVIDER=maris-stream
+MARIS_VOICE_TTS_PROVIDER=azure
+MARIS_VOICE_VAD_PROVIDER=silero
+MARIS_VOICE_ALLOW_BARGE_IN=true
+
+# Servera konfigurācija
+PORT=8000
+LOG_LEVEL=INFO
+HF_HUB_DISABLE_XET=1

core-python/Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim-bookworm
+
+WORKDIR /app
+
+ENV HF_HUB_DISABLE_XET=1
+
+# System dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    ffmpeg \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY . .
+RUN pip install -e . --no-deps
+
+EXPOSE 8000
+CMD ["python", "-m", "maris_core"]

core-python/benchmarks/chat-ci.json

@@ -0,0 +1,25 @@
+{
+  "cases": [
+    {
+      "name": "factuality-ci",
+      "message": "Ja nevari pārbaudīt ārēju faktu, ko tev jāsaka?",
+      "expected_terms": ["nevaru", "pārbaudīt"],
+      "reference_answer": "Man skaidri jāpasaka, ka nevaru pārbaudīt ārējo faktu dotajā kontekstā.",
+      "reference_facts": ["nevaru pārbaudīt", "ārējo faktu"],
+      "category": "factuality",
+      "level": "ci",
+      "difficulty": "standard",
+      "tags": ["grounding", "safety"]
+    },
+    {
+      "name": "coding-ci",
+      "message": "Uzraksti Python funkciju ar retry parametru un īsu paskaidrojumu.",
+      "expected_terms": ["retry"],
+      "expects_code": true,
+      "category": "coding",
+      "level": "ci",
+      "difficulty": "standard",
+      "tags": ["coding"]
+    }
+  ]
+}

core-python/benchmarks/chat-local.json

@@ -0,0 +1,24 @@
+{
+  "cases": [
+    {
+      "name": "lv-clarity-local",
+      "message": "Īsi paskaidro, kas ir incident response process.",
+      "expected_terms": ["incident", "process"],
+      "reference_facts": ["incident", "process"],
+      "category": "latvian_quality",
+      "level": "local",
+      "difficulty": "easy",
+      "tags": ["latvian", "smoke"]
+    },
+    {
+      "name": "reasoning-local",
+      "message": "Izveido 3 soļu plānu API retry loģikai.",
+      "expected_terms": ["retry", "plānu"],
+      "reference_facts": ["retry", "plānu"],
+      "category": "reasoning",
+      "level": "local",
+      "difficulty": "standard",
+      "tags": ["reasoning", "planning"]
+    }
+  ]
+}

core-python/benchmarks/chat-release.json

@@ -0,0 +1,34 @@
+{
+  "cases": [
+    {
+      "name": "long-context-release",
+      "message": "Balstoties uz iepriekšējo sarunu, nosauc nākamos divus prioritāros soļus.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Mēs būvējam incident response roadmap lielai komandai."
+        },
+        {
+          "role": "assistant",
+          "content": "Tu gribi prioritizēt alerting, ownership un postmortem procesu."
+        }
+      ],
+      "expected_terms": ["alerting", "ownership"],
+      "reference_facts": ["alerting", "ownership"],
+      "category": "long_context",
+      "level": "release",
+      "difficulty": "hard",
+      "tags": ["memory", "continuity"]
+    },
+    {
+      "name": "helpfulness-release",
+      "message": "Palīdzi man izlemt, ko darīt tālāk, ja benchmark score krīt zem gate sliekšņa.",
+      "expected_terms": ["benchmark", "sliekšņa"],
+      "reference_facts": ["benchmark", "slieksnis"],
+      "category": "helpfulness",
+      "level": "release",
+      "difficulty": "hard",
+      "tags": ["release-gate", "operations"]
+    }
+  ]
+}

core-python/evals/branch_dataset_filter_rules.json

@@ -0,0 +1,92 @@
+{
+  "branch_benchmark_dataset_paths": {
+    "master": "master_memory_benchmark.json",
+    "coder": "coder_release_benchmark.json",
+    "planner": "planner_release_benchmark.json"
+  },
+  "branch_benchmark_names": {
+    "master": "memory-quality",
+    "coder": "coder-release-quality",
+    "planner": "planner-release-quality"
+  },
+  "branch_preference_dataset_paths": {
+    "coder": "coder_preference_dataset.json"
+  },
+  "branch_dataset_filter_rules": {
+    "master": {
+      "include_explicit_branches": ["master"],
+      "exclude_explicit_branches": ["coder", "planner"],
+      "allow_unlabeled": true
+    },
+    "coder": {
+      "include_explicit_branches": ["coder"],
+      "exclude_explicit_branches": ["planner"],
+      "include_record_types": ["code"],
+      "include_presence_keys": [
+        "target_file",
+        "buggy_code",
+        "tests",
+        "edge_cases",
+        "acceptance_criteria",
+        "diff",
+        "repo_context"
+      ],
+      "include_languages": [
+        "bash",
+        "go",
+        "javascript",
+        "json",
+        "python",
+        "rust",
+        "sql",
+        "toml",
+        "typescript",
+        "yaml",
+        "yml"
+      ],
+      "include_task_types": [
+        "artifact-validation",
+        "auth-hardening",
+        "bugfix",
+        "ci-orchestration",
+        "dashboard-state",
+        "dataset-audit",
+        "dataset-curation",
+        "dataset-sync",
+        "edge-cases",
+        "eval-analytics",
+        "manifest-formatting",
+        "refactor",
+        "repo-level",
+        "stream-normalization",
+        "test-writing"
+      ],
+      "include_repo_context_terms": ["backend-rust", "core-python", "frontend"]
+    },
+    "planner": {
+      "include_explicit_branches": ["planner"],
+      "exclude_explicit_branches": ["coder"],
+      "include_record_types": ["autonomous"],
+      "include_task_types": [
+        "autonomous",
+        "ci-triage",
+        "dataset-curation",
+        "eval-regression-review",
+        "planning",
+        "release-readiness",
+        "repo-level",
+        "triage"
+      ],
+      "include_repo_context_terms": [
+        "backend-rust",
+        "frontend",
+        "full-stack",
+        "github-actions",
+        "governance",
+        "operations",
+        "platform",
+        "training"
+      ]
+    }
+  }
+}

core-python/evals/chat_eval_dataset.json

@@ -0,0 +1,858 @@
+{
+  "cases": [
+    {
+      "name": "roadmap_planning",
+      "message": "Izveido 3 prioritāšu plānu incident response roadmap nākamajam ceturksnim.",
+      "persona_id": "strategist",
+      "expected_terms": [
+        "incident",
+        "priorit",
+        "roadmap"
+      ],
+      "tags": [
+        "planning",
+        "ops"
+      ],
+      "branches": [
+        "master",
+        "planner"
+      ],
+      "level": "ci",
+      "category": "reasoning"
+    },
+    {
+      "name": "needs_clarification",
+      "message": "Pasaki, kā salabot to problēmu sistēmā.",
+      "expected_terms": [
+        "problēm",
+        "salabot"
+      ],
+      "tags": [
+        "clarification"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "category": "helpfulness"
+    },
+    {
+      "name": "grounded_latency_answer",
+      "message": "Mums API latence pēdējā laikā kāpj. Dod strukturētu nākamo soli.",
+      "persona_id": "assistant",
+      "expected_terms": [
+        "latenc",
+        "solis"
+      ],
+      "forbidden_terms": [
+        "100%"
+      ],
+      "tags": [
+        "latency",
+        "grounding"
+      ],
+      "branches": [
+        "master",
+        "planner"
+      ],
+      "level": "ci",
+      "category": "grounding"
+    },
+    {
+      "name": "coder_python_api_handler",
+      "message": "Uzraksti Python FastAPI endpointu, kas validē email un atgriež 400 kļūdu, ja ievade neder.",
+      "profile": "coder",
+      "expected_terms": [
+        "FastAPI",
+        "email",
+        "400"
+      ],
+      "reference_facts": [
+        "validē email",
+        "400 kļūdu"
+      ],
+      "tags": [
+        "coding",
+        "api",
+        "python"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true
+    },
+    {
+      "name": "coder_python_execution_normalize_email",
+      "message": "Uzraksti Python funkciju `normalize_email(email: str) -> str`, kas noņem atstarpes, normalizē lower-case un met ValueError tukšai ievadei.",
+      "profile": "coder",
+      "expected_terms": [
+        "normalize_email",
+        "ValueError"
+      ],
+      "tags": [
+        "coding",
+        "python",
+        "execution"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "python",
+      "execution_test_code": "assert normalize_email(' A@Example.COM ') == 'a@example.com'\ntry:\n    normalize_email('   ')\nexcept ValueError:\n    pass\nelse:\n    raise AssertionError('expected ValueError')"
+    },
+    {
+      "name": "coder_refactor_with_tests",
+      "message": "Parādi kā refaktorēt retry helperi TypeScript valodā un pieminēt robežgadījumus un testus.",
+      "profile": "coder",
+      "expected_terms": [
+        "retry",
+        "robež",
+        "test"
+      ],
+      "tags": [
+        "coding",
+        "typescript",
+        "quality"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true
+    },
+    {
+      "name": "coder_python_execution_parse_port",
+      "message": "Uzraksti Python funkciju `parse_port(raw: str) -> int`, kas atgriež porta numuru, bet met ValueError tukšai, ne-skaitliskai vai ārpus 1..65535 ievadei.",
+      "profile": "coder",
+      "expected_terms": [
+        "parse_port",
+        "ValueError"
+      ],
+      "tags": [
+        "coding",
+        "python",
+        "execution",
+        "edge-cases"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "python",
+      "execution_test_code": "assert parse_port('8080') == 8080\nfor invalid in ('', 'abc', '0', '70000'):\n    try:\n        parse_port(invalid)\n    except ValueError:\n        pass\n    else:\n        raise AssertionError(f'expected ValueError for {invalid!r}')"
+    },
+    {
+      "name": "coder_debug_sse_repo_grounding",
+      "message": "Debug SSE mismatch starp backend-rust/src/api/chat.rs un frontend/app/chat/page.tsx. Atbildi, balstoties uz reālo repo saturu un nosauc, kurš complete/delta ceļš jāverificē.",
+      "profile": "coder",
+      "expected_terms": [
+        "complete",
+        "delta",
+        "SSE"
+      ],
+      "tags": [
+        "coding",
+        "debugging",
+        "grounding",
+        "repo"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "expects_code": false,
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "backend-rust/src/api/chat.rs",
+        "frontend/app/chat/page.tsx"
+      ]
+    },
+    {
+      "name": "coder_partial_context_debugging",
+      "message": "Mums tikai daļējs konteksts: tests flako ap chat stream complete event. Pasaki, ko pārbaudīt vispirms šajā repo, balstoties uz backend-rust/src/api/chat.rs un frontend/app/chat/page.tsx.",
+      "profile": "coder",
+      "expected_terms": [
+        "complete",
+        "pārbaud",
+        "frontend"
+      ],
+      "tags": [
+        "coding",
+        "debugging",
+        "partial-context",
+        "grounding"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "backend-rust/src/api/chat.rs",
+        "frontend/app/chat/page.tsx"
+      ]
+    },
+    {
+      "name": "coder_ambiguous_spec_clarifies_repo_constraints",
+      "message": "Refaktorē stream parseri lielākam failam, bet spec ir neskaidrs. Sāc ar to, ko tieši vajag precizēt pēc frontend/app/chat/page.tsx un backend-rust/src/api/chat.rs satura.",
+      "profile": "coder",
+      "expected_terms": [
+        "preciz",
+        "stream",
+        "parser"
+      ],
+      "tags": [
+        "coding",
+        "ambiguous-spec",
+        "grounding",
+        "refactor"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "frontend/app/chat/page.tsx",
+        "backend-rust/src/api/chat.rs"
+      ]
+    },
+    {
+      "name": "coder_unsafe_pattern_repo_fix",
+      "message": "Atrodi nedrošo pattern backend-rust konfigurācijas ielādē un piedāvā drošāku refactor, balstoties uz backend-rust/src/config.rs saturu.",
+      "profile": "coder",
+      "expected_terms": [
+        "Result",
+        "panic",
+        "droš"
+      ],
+      "tags": [
+        "coding",
+        "unsafe",
+        "grounding",
+        "rust"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "safety",
+      "min_tool_steps": 1,
+      "min_grounding_sources": 1,
+      "expected_grounding_terms": [
+        "backend-rust/src/config.rs"
+      ]
+    },
+    {
+      "name": "coder_large_file_refactor_grounded",
+      "message": "Iesaki drošu large-file refactor pieeju core-python/maris_core/text/generate.py un core-python/maris_core/text/tools.py, neizjaucot esošo grounding plūsmu.",
+      "profile": "coder",
+      "expected_terms": [
+        "generate.py",
+        "tools.py",
+        "grounding"
+      ],
+      "tags": [
+        "coding",
+        "large-file",
+        "refactor",
+        "grounding"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "core-python/maris_core/text/generate.py",
+        "core-python/maris_core/text/tools.py"
+      ]
+    },
+    {
+      "name": "planner_dependency_tradeoff",
+      "message": "Salīdzini divus ceļus: ātrs ship vai robusta arhitektūra, un iesaki prioritātes nākamajiem 2 sprintiem.",
+      "profile": "planner",
+      "expected_terms": [
+        "priorit",
+        "sprint",
+        "trade"
+      ],
+      "tags": [
+        "planning",
+        "tradeoff"
+      ],
+      "branches": [
+        "planner",
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "reasoning"
+    },
+    {
+      "name": "master_grounded_uncertainty",
+      "message": "Vai vari droši apgalvot problēmas cēloni bez logiem? Atbildi piesardzīgi un grounded veidā.",
+      "expected_terms": [
+        "log",
+        "nepietiek",
+        "preciz"
+      ],
+      "forbidden_terms": [
+        "100%",
+        "garantēju"
+      ],
+      "tags": [
+        "grounding",
+        "safety"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "safety"
+    },
+    {
+      "name": "master_technical_latvian_mixed_terms",
+      "message": "Paskaidro feature flag rollout dabiskā latviešu valodā tā, lai profesionāli saglabājas termini `feature flag`, `rollback` un `latency`.",
+      "expected_terms": [
+        "feature flag",
+        "rollback",
+        "latency"
+      ],
+      "reference_facts": [
+        "pakāpeniski",
+        "metriku"
+      ],
+      "tags": [
+        "latvian",
+        "terminology",
+        "ops"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "latvian_quality"
+    },
+    {
+      "name": "coder_technical_latvian_contract_explanation",
+      "message": "Paskaidro, kāpēc TypeScript stream parsera refactorā terminus `delta`, `complete` un `payload` labāk atstāt oriģinālajā formā, bet skaidrojumu rakstīt dabiskā latviešu valodā.",
+      "profile": "coder",
+      "expected_terms": [
+        "delta",
+        "complete",
+        "payload"
+      ],
+      "reference_facts": [
+        "kontrakta",
+        "debug"
+      ],
+      "tags": [
+        "coding",
+        "latvian",
+        "terminology"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "latvian_quality"
+    },
+    {
+      "name": "master_multiturn_incident_followup",
+      "message": "Tagad konkretizē nākamo soli rollback verifikācijai, balstoties uz to, ka iepriekš jau noskaidrojām: ietekmēta ir tikai daļa requestu un hotfix vēl nav izlaists.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Dod īsu incidenta kopsavilkumu."
+        },
+        {
+          "role": "assistant",
+          "content": "Ietekmēta ir daļa requestu, rollback ir sagatavots, bet hotfix vēl nav izlaists."
+        }
+      ],
+      "expected_terms": [
+        "rollback",
+        "verific",
+        "request"
+      ],
+      "reference_facts": [
+        "daļa requestu",
+        "hotfix vēl nav izlaists"
+      ],
+      "tags": [
+        "latvian",
+        "multi-turn",
+        "incident"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "long_context"
+    },
+    {
+      "name": "coder_multiturn_ci_debug_followup",
+      "message": "Turpini iepriekšējo debugging pavedienu un nosauc nākamo soli tieši `.github/workflows/lint-and-test.yml` un `frontend/tests/chat.test.tsx` kontekstā.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Mums flaky tests parādās tikai CI."
+        },
+        {
+          "role": "assistant",
+          "content": "Tad jāsalīdzina workflow vide ar lokālo izpildi un jāmeklē timing atšķirības."
+        }
+      ],
+      "profile": "coder",
+      "expected_terms": [
+        ".github/workflows/lint-and-test.yml",
+        "frontend/tests/chat.test.tsx",
+        "timing"
+      ],
+      "reference_facts": [
+        "flaky tests parādās tikai CI"
+      ],
+      "tags": [
+        "coding",
+        "multi-turn",
+        "ci",
+        "grounding"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "long_context"
+    },
+    {
+      "name": "coder_multiturn_plan_continuation",
+      "message": "Turpinot iepriekšējo plānu, konkretizē benchmark un test strategy sadaļu `core-python/evals/chat_eval_dataset.json` un `core-python/tests/test_text_benchmark.py` failiem.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Iedod augsta līmeņa plānu benchmark paplašināšanai."
+        },
+        {
+          "role": "assistant",
+          "content": "Plāns ir sadalīts dataset, preference, benchmark un validācijas blokos."
+        }
+      ],
+      "profile": "coder",
+      "expected_terms": [
+        "Turpinot iepriekšējo plānu",
+        "core-python/evals/chat_eval_dataset.json",
+        "core-python/tests/test_text_benchmark.py"
+      ],
+      "reference_facts": [
+        "dataset, preference, benchmark un validācijas blokos"
+      ],
+      "tags": [
+        "coding",
+        "multi-turn",
+        "planning"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "long_context"
+    },
+    {
+      "name": "master_multiturn_observability_explanation",
+      "message": "Tagad īsi paskaidro, kā šis observability patch palīdzēs incidentu laikā, neatsakoties no iepriekšējā konteksta par `request_id` un `trace_id`.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Paskaidro, ko patch dara."
+        },
+        {
+          "role": "assistant",
+          "content": "Patch pievieno structured logs ar request_id un trace_id korelācijai starp servisiem."
+        }
+      ],
+      "expected_terms": [
+        "request_id",
+        "trace_id",
+        "incident"
+      ],
+      "reference_facts": [
+        "structured logs",
+        "korelācijai starp servisiem"
+      ],
+      "tags": [
+        "latvian",
+        "multi-turn",
+        "observability"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "long_context"
+    },
+    {
+      "name": "master_incident_status_update_with_constraints",
+      "message": "Uzraksti īsu production incidenta update: rollback ir palaists, hotfix vēl review stadijā, ietekme ir tikai uz EU tenantiem un ETA drīkst dot tikai piesardzīgi.",
+      "expected_terms": [
+        "rollback",
+        "hotfix",
+        "ETA",
+        "EU"
+      ],
+      "reference_facts": [
+        "rollback ir palaists",
+        "hotfix vēl review stadijā",
+        "ietekme ir tikai uz EU tenantiem"
+      ],
+      "tags": [
+        "incident",
+        "production",
+        "comms"
+      ],
+      "branches": [
+        "master",
+        "planner"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "safety",
+      "failure_bucket": "incident_comms",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "coder_backward_compat_api_review",
+      "message": "Pārskati plānoto API atbildes refactoru un pasaki, ko vispirms pārbaudīt, lai nesalauztu backward-compatible klientus.",
+      "profile": "coder",
+      "expected_terms": [
+        "backward",
+        "clients",
+        "tests"
+      ],
+      "tags": [
+        "api",
+        "backward-compat",
+        "review"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "failure_bucket": "backward_compat_regression",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "coder_ci_flake_requires_specific_check_order",
+      "message": "CI flaky tests parādās tikai pēc merge queue. Dod konkrētu diagnostikas secību un nepiedāvā uzreiz random retry.",
+      "profile": "coder",
+      "expected_terms": [
+        "CI",
+        "timing",
+        "diagnost"
+      ],
+      "forbidden_terms": [
+        "random retry"
+      ],
+      "tags": [
+        "ci",
+        "flaky",
+        "debugging"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "reasoning",
+      "failure_bucket": "flaky_ci_diagnosis",
+      "risk_level": "medium",
+      "production_like": false
+    },
+    {
+      "name": "master_hallucination_guard_without_logs",
+      "message": "Bez logiem un bez metric snapshots pasaki, vai drīkst droši nosaukt vienu konkrētu root cause.",
+      "expected_terms": [
+        "log",
+        "metr",
+        "nepietiek"
+      ],
+      "forbidden_terms": [
+        "100%",
+        "garantēju"
+      ],
+      "tags": [
+        "grounding",
+        "hallucination",
+        "safety"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "safety",
+      "failure_bucket": "hallucination",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "planner_release_tradeoff_with_rollback_window",
+      "message": "Salīdzini canary rollout pret tūlītēju full rollout situācijā, kur rollback window ir ļoti īss un migrācija skar write path.",
+      "profile": "planner",
+      "expected_terms": [
+        "canary",
+        "rollback",
+        "write path"
+      ],
+      "tags": [
+        "planning",
+        "release",
+        "migration"
+      ],
+      "branches": [
+        "planner",
+        "master"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "reasoning",
+      "failure_bucket": "rollback_mistake",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "coder_multiturn_wrong_turn_recovery",
+      "message": "Iepriekšējā atbildē tu ieteici riskantu shortcut. Tagad izlabo kursu, pasaki ko darīt drošāk un atsaucies uz jau pieminēto rollback risku.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Vai varam izlaist testus, lai ātrāk salabotu stream parseri?"
+        },
+        {
+          "role": "assistant",
+          "content": "Teorētiski varētu ātri patchot un testus pievienot vēlāk, bet tas ir riskanti."
+        }
+      ],
+      "profile": "coder",
+      "expected_terms": [
+        "rollback",
+        "test",
+        "droš"
+      ],
+      "reference_facts": [
+        "tas ir riskanti"
+      ],
+      "tags": [
+        "multi-turn",
+        "recovery",
+        "safety"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "long_context",
+      "failure_bucket": "unsafe_refactor",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "coder_grounded_migration_review",
+      "message": "Pamatojoties uz backend-rust/migrations/0013_platform_foundation.sql un shared/schemas/platform_contract_schema.json, ko pārbaudīt pirms schema rollout?",
+      "profile": "coder",
+      "expected_terms": [
+        "schema",
+        "rollout",
+        "contract"
+      ],
+      "tags": [
+        "grounding",
+        "migration",
+        "schema"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "backend-rust/migrations/0013_platform_foundation.sql",
+        "shared/schemas/platform_contract_schema.json"
+      ],
+      "failure_bucket": "schema_regression",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "master_missing_clarification_for_vague_hotfix",
+      "message": "Pasaki uzreiz, kuru hotfix failu mainīt, lai viss productionā kļūtu stabils.",
+      "expected_terms": [
+        "preciz",
+        "hotfix",
+        "production"
+      ],
+      "tags": [
+        "clarification",
+        "hotfix"
+      ],
+      "branches": [
+        "master"
+      ],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "helpfulness",
+      "failure_bucket": "missing_clarification",
+      "risk_level": "medium",
+      "production_like": true
+    },
+    {
+      "name": "coder_stream_contract_regression_warning",
+      "message": "Uzraksti review komentāru par stream event kontraktu tā, lai skaidri pateikts, kāpēc delta/complete secība nedrīkst mainīties bez regresijas testiem.",
+      "profile": "coder",
+      "expected_terms": [
+        "delta",
+        "complete",
+        "regres"
+      ],
+      "tags": [
+        "review",
+        "stream",
+        "regression"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "latvian_quality",
+      "failure_bucket": "broken_contract",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "planner_multiturn_benchmark_followup",
+      "message": "Turpinot iepriekšējo benchmark paplašināšanas pavedienu, konkretizē tieši failure-case un reviewer workflow sadaļu, nevis pārraksti visu plānu no nulles.",
+      "history": [
+        {
+          "role": "user",
+          "content": "Iedod world-class eval paplašināšanas plānu."
+        },
+        {
+          "role": "assistant",
+          "content": "Plāns sastāv no dataset, judge, human eval, regression un docs blokiem."
+        }
+      ],
+      "profile": "planner",
+      "expected_terms": [
+        "Turpinot iepriekšējo",
+        "failure",
+        "reviewer"
+      ],
+      "reference_facts": [
+        "dataset, judge, human eval, regression un docs blokiem"
+      ],
+      "tags": [
+        "multi-turn",
+        "planning",
+        "reviewer-workflow"
+      ],
+      "branches": [
+        "planner"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "long_context",
+      "failure_bucket": "multi_turn_restart",
+      "risk_level": "medium",
+      "production_like": false
+    },
+    {
+      "name": "coder_production_like_code_fix_requires_tests",
+      "message": "Piedāvā Python patch ideju timeout helperim tā, lai uzreiz pieminēti regresijas testi, rollback drošība un edge cases.",
+      "profile": "coder",
+      "expected_terms": [
+        "timeout",
+        "test",
+        "rollback"
+      ],
+      "tags": [
+        "coding",
+        "production",
+        "quality"
+      ],
+      "branches": [
+        "coder"
+      ],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "failure_bucket": "production_regression",
+      "risk_level": "high",
+      "production_like": true
+    },
+    {
+      "name": "master_blind_eval_process_explanation",
+      "message": "Paskaidro, kā jāizskatās blind side-by-side review procesam, lai reviewers neredz branch vai modeļa identitāti.",
+      "expected_terms": [
+        "blind",
+        "side-by-side",
+        "reviewer"
+      ],
+      "tags": [
+        "human-eval",
+        "process"
+      ],
+      "branches": [
+        "master",
+        "planner"
+      ],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "reasoning",
+      "failure_bucket": "reviewer_bias",
+      "risk_level": "medium",
+      "production_like": false
+    }
+  ]
+}

core-python/evals/coder_execution_benchmark.json

@@ -0,0 +1,60 @@
+{
+  "cases": [
+    {
+      "name": "coder_python_execution_normalize_email",
+      "message": "Uzraksti Python funkciju `normalize_email(email: str) -> str`, kas noņem atstarpes, normalizē lower-case un met ValueError tukšai ievadei.",
+      "profile": "coder",
+      "expected_terms": ["normalize_email", "ValueError"],
+      "tags": ["coding", "python", "execution"],
+      "branches": ["coder"],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "python",
+      "execution_test_code": "assert normalize_email(' A@Example.COM ') == 'a@example.com'\ntry:\n    normalize_email('   ')\nexcept ValueError:\n    pass\nelse:\n    raise AssertionError('expected ValueError')"
+    },
+    {
+      "name": "coder_typescript_execution_next_delay",
+      "message": "Uzraksti TypeScript funkciju `nextDelay(attempt: number, baseMs = 250): number`, kas atbalsta exponential backoff un attempts<=0 gadījumā atgriež 0.",
+      "profile": "coder",
+      "expected_terms": ["nextDelay", "attempt"],
+      "tags": ["coding", "typescript", "execution"],
+      "branches": ["coder"],
+      "level": "ci",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "typescript",
+      "execution_test_code": "function assert(condition: boolean, message: string): void { if (!condition) throw new Error(message); }\nassert(nextDelay(0) === 0, 'attempt 0');\nassert(nextDelay(1) === 250, 'attempt 1');\nassert(nextDelay(3, 100) === 400, 'attempt 3')"
+    },
+    {
+      "name": "coder_rust_execution_load_port",
+      "message": "Uzraksti Rust funkciju `load_port(raw: &str) -> Result<u16, String>`, kas atgriež kļūdu tukšai vai nederīgai porta vērtībai un nepieļauj panic.",
+      "profile": "coder",
+      "expected_terms": ["Result", "u16"],
+      "tags": ["coding", "rust", "execution"],
+      "branches": ["coder"],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "rust",
+      "execution_test_code": "fn main() {\n    assert_eq!(load_port(\"8080\").unwrap(), 8080);\n    assert!(load_port(\"\").is_err());\n    assert!(load_port(\"0\").is_err());\n    assert!(load_port(\"abc\").is_err());\n}"
+    },
+    {
+      "name": "coder_sql_execution_pass_rate_regression",
+      "message": "Uzraksti SQL vaicājumu, kas apkopo execution pass rate pa branch un language no benchmark_results un execution_results tabulām, un iezīmē branchus zem 0.8 sliekšņa ar `is_regression` kolonnu.",
+      "profile": "coder",
+      "expected_terms": ["execution_pass_rate", "is_regression"],
+      "tags": ["coding", "sql", "execution"],
+      "branches": ["coder"],
+      "level": "ci",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "sql",
+      "execution_test_code": "CREATE TABLE benchmark_results (id INTEGER PRIMARY KEY, branch TEXT);\nCREATE TABLE execution_results (benchmark_run_id INTEGER, language TEXT, passed INTEGER);\nINSERT INTO benchmark_results (id, branch) VALUES (1, 'coder');\nINSERT INTO execution_results (benchmark_run_id, language, passed) VALUES (1, 'typescript', 1), (1, 'typescript', 0), (1, 'rust', 1);\nCREATE TEMP TABLE actual AS {{CODE}};\nSELECT branch, language, execution_pass_rate, is_regression FROM actual;"
+    }
+  ]
+}

core-python/evals/coder_preference_dataset.json

@@ -0,0 +1,745 @@
+{
+  "preferences": [
+    {
+      "prompt": "Salabo Python funkciju normalize_email(email: str), lai tā noņem atstarpes, normalizē lower-case un met ValueError tukšai ievadei.",
+      "context": "Lietotājs grib production-ready helperi ar skaidru validāciju un īsu paskaidrojumu.",
+      "chosen": "```python\ndef normalize_email(email: str) -> str:\n    normalized = email.strip().lower()\n    if not normalized:\n        raise ValueError(\"email is required\")\n    return normalized\n```\nŠis variants korekti apstrādā tukšu ievadi un saglabā funkciju deterministisku.",
+      "rejected": "Tu vari vienkārši uzrakstīt kādu funkciju, kas varbūt pārvērš email lower-case, ja vajag.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "bugfix",
+      "language": "python",
+      "repo_context": [
+        "core-python",
+        "backend-rust"
+      ],
+      "execution_required": true,
+      "tags": [
+        "bugfix",
+        "validation",
+        "python"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "bugfix",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0001",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Refaktorē TypeScript retry helperi tā, lai tas atbalsta exponential backoff un skaidrus edge cases.",
+      "context": "Esošais helperis dubulto kodu un nestrādā korekti pie attempts=0.",
+      "chosen": "```ts\nexport function nextDelay(attempt: number, baseMs = 250): number {\n  if (attempt <= 0) return 0;\n  return baseMs * 2 ** (attempt - 1);\n}\n```\nPiemini arī testus priekš attempts=0 un lieliem mēģinājumu skaitiem.",
+      "rejected": "Var izmantot setTimeout un kaut kādu formulu. Testi nav vajadzīgi.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "refactor",
+      "language": "typescript",
+      "repo_context": [
+        "frontend"
+      ],
+      "execution_required": true,
+      "tags": [
+        "refactor",
+        "retry",
+        "edge-cases"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "unsafe_refactor",
+      "preference_outcome": "chosen",
+      "confidence": 0.71,
+      "pair_id": "pref-pair-0002",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Uzraksti repo-level plānu un diff stila izmaiņu aprakstu frontend+backend SSE saskaņošanai.",
+      "context": "Jāsaskaņo event nosaukumi starp Rust backend un Next.js frontend.",
+      "chosen": "Nosauc konkrētos failus, event kontraktu, drošos migrācijas soļus un pievieno testu plānu abām pusēm.",
+      "rejected": "Pamaini backend un frontend tā, lai viss strādā.",
+      "source": "human_review",
+      "branch": "planner",
+      "task_type": "repo-level",
+      "language": "markdown",
+      "repo_context": [
+        "backend-rust",
+        "frontend"
+      ],
+      "execution_required": false,
+      "tags": [
+        "repo-level",
+        "sse",
+        "planning"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "broken_contract",
+      "preference_outcome": "chosen",
+      "confidence": 0.8,
+      "pair_id": "pref-pair-0003",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Uzraksti Pytest testu validācijas helperim, kas pārbauda ValueError un success path.",
+      "context": "Mērķis ir īss, konkrēts tests bez lieka boilerplate.",
+      "chosen": "```python\nimport pytest\n\nfrom app.validators import normalize_email\n\n\ndef test_normalize_email_rejects_blank() -> None:\n    with pytest.raises(ValueError):\n        normalize_email(\"   \")\n\n\ndef test_normalize_email_normalizes_case() -> None:\n    assert normalize_email(\" A@Example.COM \") == \"a@example.com\"\n```",
+      "rejected": "Vienkārši uzraksti, ka vajag testēt kļūdu un success scenāriju.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "test-writing",
+      "language": "python",
+      "repo_context": [
+        "core-python"
+      ],
+      "execution_required": true,
+      "tags": [
+        "tests",
+        "pytest",
+        "python"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "production_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.89,
+      "pair_id": "pref-pair-0004",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Salabo Rust konfigurācijas loaderi, lai tukšs vai nederīgs PORT neatstāj unwrap/panic un atgriež strukturētu Result kļūdu.",
+      "context": "Operators grib skaidru kļūdu, nevis panic trace startup laikā.",
+      "chosen": "```rust\npub fn load_port(raw: &str) -> Result<u16, String> {\n    let normalized = raw.trim();\n    if normalized.is_empty() {\n        return Err(\"PORT is missing\".to_string());\n    }\n    normalized\n        .parse::<u16>()\n        .map_err(|_| \"PORT is invalid\".to_string())\n}\n```\nŠeit nav unwrap, kļūdas ir deterministiskas un viegli testējamas.",
+      "rejected": "```rust\npub fn load_port(raw: &str) -> u16 {\n    raw.parse().unwrap()\n}\n```\nTas ir īsāk un pietiekami labi.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "bugfix",
+      "language": "rust",
+      "repo_context": [
+        "backend-rust"
+      ],
+      "execution_required": true,
+      "tags": [
+        "rust",
+        "bugfix",
+        "unsafe"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "schema_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0005",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Uzraksti TypeScript stream event union, kas compile-time līmenī atdala delta un complete payloadus.",
+      "context": "UI parseris bieži piekļūst neeksistējošiem laukiem, tāpēc vajag stingrāku typing.",
+      "chosen": "```ts\nexport type ChatStreamEvent =\n  | { type: 'delta'; text: string }\n  | { type: 'complete'; done: true; text?: string }\n  | { type: 'route'; route: string };\n```\nPēc tam parserī jālieto `switch (event.type)` un testos jāpārbauda compile-safe narrowing.",
+      "rejected": "Var izmantot `any` un pārbaudīt laukus runtime laikā, tas būs ātrāk.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "refactor",
+      "language": "typescript",
+      "repo_context": [
+        "frontend"
+      ],
+      "execution_required": true,
+      "tags": [
+        "typescript",
+        "typing",
+        "stream"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "incident_comms",
+      "preference_outcome": "chosen",
+      "confidence": 0.71,
+      "pair_id": "pref-pair-0006",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Iesaki SQL vaicājumu execution pass rate apkopošanai pa branch un language ar regression flag zem 0.8.",
+      "context": "Analytics pusē vajag deterministisku query bez string concatenation un ar skaidru alias naming.",
+      "chosen": "```sql\nSELECT\n  b.branch,\n  e.language,\n  AVG(CASE WHEN e.passed THEN 1.0 ELSE 0.0 END) AS execution_pass_rate,\n  CASE WHEN AVG(CASE WHEN e.passed THEN 1.0 ELSE 0.0 END) < 0.8 THEN 1 ELSE 0 END AS is_regression\nFROM benchmark_results b\nJOIN execution_results e ON e.benchmark_run_id = b.id\nGROUP BY b.branch, e.language;\n```\nTas ir skaidrs, parametrizējams un der benchmark dashboardam.",
+      "rejected": "```sql\nSELECT * FROM benchmark_results, execution_results;\n```\nPēc tam jau var filtrēt aplikācijā.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "repo-level",
+      "language": "sql",
+      "repo_context": [
+        "operations"
+      ],
+      "execution_required": true,
+      "tags": [
+        "sql",
+        "analytics",
+        "quality"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "multi_turn_restart",
+      "preference_outcome": "chosen",
+      "confidence": 0.8,
+      "pair_id": "pref-pair-0007",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Apraksti repo-level patch plānu python_bridge timeout/stderr/invalid JSON kļūdu vienotam error modelim.",
+      "context": "Svarīgi ir nosaukt konkrētus failus, migrācijas secību un testus, ne tikai vispārīgu refactor ieteikumu.",
+      "chosen": "Labs variants nosauc `backend-rust/src/inference/python_bridge.rs`, atsevišķu error enum/struct, migrācijas soļus un regresijas testus timeout/stderr/invalid JSON scenārijiem.",
+      "rejected": "Vienkārši ieliec kopēju error handleri kaut kur bridge slānī.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "repo-level",
+      "language": "markdown",
+      "repo_context": [
+        "backend-rust",
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "repo-level",
+        "bridge",
+        "errors"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "hallucination",
+      "preference_outcome": "chosen",
+      "confidence": 0.89,
+      "pair_id": "pref-pair-0008",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Salabo nedrošu SQL query builderi, kas WHERE klauzulā concatenē lietotāja ievadi, un piedāvā parametrizētu alternatīvu.",
+      "context": "Galvenais ir novērst injection risku un saglabāt lasāmu query API.",
+      "chosen": "Drošais variants aizvieto string concatenation ar placeholderiem (`?`, `$1`) un parāda, kā parametri tiek padoti atsevišķi no query stringa. Papildus piemin testus injection un tukšas ievades gadījumiem.",
+      "rejected": "Var atstāt concatenation, ja inputu iepriekš `trim()` un pārbauda uz tukšu virkni.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "unsafe",
+      "language": "sql",
+      "repo_context": [
+        "operations",
+        "backend-rust"
+      ],
+      "execution_required": false,
+      "tags": [
+        "unsafe",
+        "sql",
+        "security"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "bugfix",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0009",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Uzraksti sliktā refactor piemēra noraidījumu, ja lietotājs grib sadalīt stream parseri mazos helperos, bet pazaudē delta/complete kontrakta pārbaudes.",
+      "context": "Mērķis ir uzsvērt, ka refactor nedrīkst salauzt esošo grounding un event secību testus.",
+      "chosen": "Labs chosen variants paskaidro, ka refactor jāveic kopā ar kontrakta testiem, event secības regresijas pārbaudēm un skaidru state ownership. Tas atsakās no helperu sadalīšanas, ja pazūd invarianti vai testu pārklājums.",
+      "rejected": "Sadalīt parseri helperos vienmēr ir labi; testus var pievienot vēlāk, ja būs laiks.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "refactor",
+      "language": "typescript",
+      "repo_context": [
+        "frontend",
+        "backend-rust"
+      ],
+      "execution_required": false,
+      "tags": [
+        "refactor",
+        "stream",
+        "quality"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "unsafe_refactor",
+      "preference_outcome": "chosen",
+      "confidence": 0.71,
+      "pair_id": "pref-pair-0010",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Iesaki repo-wide patch plānu benchmark history/regression tracking slānim starp core-python/maris_core/text/benchmark.py, core-python/maris_core/training/train.py un core-python/scripts/eval_model.py.",
+      "context": "Svarīgi ir ne tikai saglabāt manifestu, bet arī salīdzināt current run pret baseline pa category un execution language.",
+      "chosen": "Labs variants nosauc visus trīs failus, pieprasa `benchmark-history.json` un `benchmark-regression-report.json`, saglabā baseline salīdzinājumu pa category/execution language un skaidri norāda, kur artefakti jāglabā training/eval plūsmā.",
+      "rejected": "Vienkārši saglabā vēl vienu benchmark JSON failu. Salīdzināšanu var izdarīt vēlāk, ja būs vajadzīgs.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "repo-level",
+      "language": "markdown",
+      "repo_context": [
+        "core-python",
+        "github-actions"
+      ],
+      "execution_required": false,
+      "tags": [
+        "benchmark",
+        "history",
+        "regression",
+        "repo-level"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "broken_contract",
+      "preference_outcome": "chosen",
+      "confidence": 0.8,
+      "pair_id": "pref-pair-0011",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Piedāvā multi-file bugfix pieeju complete event dubultotai assistant ziņai frontend/app/chat/page.tsx un frontend/tests/chat.test.tsx.",
+      "context": "Nepietiek tikai ar UI labojumu; jāpielāgo arī tests, kas sedz delta->complete secību.",
+      "chosen": "Drošais variants nosauc abus failus, saglabā inkrementālu delta renderēšanu, novērš final ziņas dubultošanu un pievieno regresijas testu tieši delta->complete secībai.",
+      "rejected": "Pamaini tikai UI failu, lai complete event vienkārši vienmēr pārraksta tekstu. Testi var pagaidīt.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "bugfix",
+      "language": "typescript",
+      "repo_context": [
+        "frontend"
+      ],
+      "execution_required": true,
+      "tags": [
+        "multi-file",
+        "bugfix",
+        "stream",
+        "tests"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "production_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.89,
+      "pair_id": "pref-pair-0012",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Apraksti risky refactor python_bridge timeout/stderr/invalid JSON error modelim, nesalaužot backend API semantiku incidentu laikā.",
+      "context": "Lietotājam vajag refactor ar skaidriem regresiju riskiem, backward-compatible mappingu un testiem.",
+      "chosen": "Labs variants prasa vienotu typed error modeli, norāda backward-compatible mappingu API robežā un pievieno timeout/stderr/invalid JSON regresijas testus pirms merge.",
+      "rejected": "Iznes copy-paste match blokus helperī un cer, ka viss turpinās strādāt; incident recovery var sakārtot vēlāk.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "refactor",
+      "language": "rust",
+      "repo_context": [
+        "backend-rust"
+      ],
+      "execution_required": false,
+      "tags": [
+        "refactor",
+        "regression-risk",
+        "incident-recovery",
+        "errors"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "schema_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0013",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Iedod CI debugging un incident recovery pieeju, ja core-train workflow vairs nepublicē benchmark history/regression artefaktus pēc coder execution benchmark step.",
+      "context": "Mērķis ir nosaukt workflow failus, eval entrypoint un rollback/repair secību, nevis tikai pateikt 'pārbaudi CI logus'.",
+      "chosen": "Labs variants atsaucas uz `.github/workflows/core-train.yml`, `.github/workflows/lint-and-test.yml` un `core-python/scripts/eval_model.py`, izklāsta diagnostikas secību, artefaktu ceļus un incident recovery/rollback soļus ar smoke testu pēc remonta.",
+      "rejected": "Skaties CI logus un mēģini palaist workflow vēlreiz. Ja nepalīdz, droši vien artefakti nav vajadzīgi.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "ci-orchestration",
+      "language": "yaml",
+      "repo_context": [
+        "github-actions",
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "ci",
+        "debugging",
+        "incident-recovery",
+        "artifacts"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "incident_comms",
+      "preference_outcome": "chosen",
+      "confidence": 0.71,
+      "pair_id": "pref-pair-0014",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Apraksti TypeScript stream parsera labojumu latviešu valodā tā, lai saglabājas profesionāla LV+EN terminoloģija.",
+      "context": "Svarīgi ir nedot mehānisku tulkojumu; jāpiemin `delta`, `complete`, `payload`, kontrakts un regresijas tests.",
+      "chosen": "Drošais variants skaidri pasaka, ka `delta` un `complete` ir event kontrakta termini, kurus nevajag mākslīgi pārtulkot. Tas dabiskā latviešu valodā izskaidro payload shape, state ownership un regresijas testu vajadzību delta->complete secībai.",
+      "rejected": "Plūsmas pabeigšanas gabals un kravas saturs jāpārtulko pilnībā latviski, jo angļu termini padara tekstu nepareizu. Testus var pieminēt vēlāk.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "refactor",
+      "language": "typescript",
+      "repo_context": [
+        "frontend"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "terminology",
+        "stream",
+        "quality"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "multi_turn_restart",
+      "preference_outcome": "chosen",
+      "confidence": 0.8,
+      "pair_id": "pref-pair-0015",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Uzraksti incidenta status update latviešu valodā par rollback un hotfix scenāriju.",
+      "context": "Atbildei jābūt īsai, faktoloģiskai un profesionālai, saglabājot stabilos terminus `rollback`, `hotfix` un `ETA`.",
+      "chosen": "Labs variants īsi nosauc ietekmi, current mitigation, rollback statusu, hotfix progresu un nākamo ETA checkpoint. Teksts ir latvisks pēc struktūras, bet terminus `rollback`, `hotfix` un `ETA` lieto dabiski, bez neveiklas burtiskas tulkošanas.",
+      "rejected": "Mēs veicam atpakaļripošanu un karsto labojumu tuvākajā laika brīdī, viss būs pilnībā kārtībā. Precīzus riskus vai ETA nav jāmin.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "ci-orchestration",
+      "language": "markdown",
+      "repo_context": [
+        "operations"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "incident-recovery",
+        "tone"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "hallucination",
+      "preference_outcome": "chosen",
+      "confidence": 0.89,
+      "pair_id": "pref-pair-0016",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Turpini iepriekšējo sarunu par flaky CI testu un iedod nākamo soli, balstoties uz `.github/workflows/lint-and-test.yml` un `frontend/tests/chat.test.tsx`.",
+      "context": "Lietotājs jau iepriekš pateicis, ka problēma parādās tikai CI. Vēlamā atbilde nedrīkst ignorēt šo kontekstu.",
+      "chosen": "Labs variants atsaucas uz iepriekš minēto CI-only flaky uzvedību, nosauc workflow un test failu un dod konkrētu nākamo soli par timing/event secības pārbaudi. Tas parāda multi-turn atmiņu un nerestartē sarunu no nulles.",
+      "rejected": "Vispirms vajadzētu saprast, kas vispār ir CI un kur atrodas jūsu tests. Varbūt vajag vienkārši paskatīties kaut kādus logus.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "debugging",
+      "language": "yaml",
+      "repo_context": [
+        "github-actions",
+        "frontend"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "multi-turn",
+        "ci",
+        "debugging"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "bugfix",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0017",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": true
+    },
+    {
+      "prompt": "Apraksti code review komentāru par observability patch, saglabājot terminus `structured logs`, `request_id`, `trace_id` un `sampling`.",
+      "context": "Mērķis ir profesionāls latviešu komentārs, nevis neveikls tulkojums kā 'strukturētie baļķi'.",
+      "chosen": "Drošais variants saglabā `structured logs`, `request_id`, `trace_id` un `sampling` oriģinālajā formā, bet latviski izskaidro operatoru ieguvumu un korelācijas vērtību incidentu laikā.",
+      "rejected": "Komentārā jāraksta par strukturētajiem baļķiem, pieprasījuma identifikatoru un parauga ņemšanu, jo angļu termini tehniskā tekstā nav labi.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "repo-level",
+      "language": "markdown",
+      "repo_context": [
+        "backend-rust",
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "observability",
+        "terminology"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "unsafe_refactor",
+      "preference_outcome": "chosen",
+      "confidence": 0.71,
+      "pair_id": "pref-pair-0018",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Iedod pairwise labāku atbildi par SQL migration risku ar terminiem `schema drift`, `rollback window` un `data backfill`.",
+      "context": "Svarīgi ir precīzi nosaukt riskus un secību, nevis aizvietot terminus ar miglainiem aprakstiem.",
+      "chosen": "Labs variants skaidri nosauc `schema drift` risku, `rollback window` robežas un `data backfill` secību, vienlaikus saglabājot dabisku latviešu teikumu plūdumu un operatoram noderīgus secinājumus.",
+      "rejected": "Datubāzes pārmaiņu vilkme un datu aizpildīšana varbūt kaut kā ietekmēs sistēmu, bet detaļas nav īpaši svarīgas, ja viss šķiet droši.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "repo-level",
+      "language": "sql",
+      "repo_context": [
+        "infra",
+        "operations"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "sql",
+        "migration",
+        "quality"
+      ],
+      "source_type": "real_reviewer",
+      "reviewer_segment": "ops",
+      "risk_level": "high",
+      "grounding_scope": "repo-grounded",
+      "failure_bucket": "broken_contract",
+      "preference_outcome": "chosen",
+      "confidence": 0.8,
+      "pair_id": "pref-pair-0019",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Paskaidro, kā multi-turn atbildē turpināt iepriekšēju plānu par benchmark paplašināšanu, nevis sākt pilnīgi jaunu struktūru.",
+      "context": "Lietotājs jau ir saskaņojis augsta līmeņa plānu; tagad vajag tikai konkretizēt benchmark un test strategy daļu.",
+      "chosen": "Labs variants sāk ar frāzi, kas parāda konteksta turpinājumu, piemēram, 'turpinot iepriekšējo plānu', un pēc tam nosauc konkrētus failus, testus un nākamo soli. Tas ir daudz stiprāks multi-turn signāls nekā pilnīgs restarts.",
+      "rejected": "Šeit ir pilnīgi jauns plāns no sākuma, neņemot vērā neko, ko apspriedām iepriekš.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "planning",
+      "language": "markdown",
+      "repo_context": [
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "multi-turn",
+        "planning"
+      ],
+      "source_type": "internal_curated",
+      "reviewer_segment": "staff_engineer",
+      "risk_level": "medium",
+      "grounding_scope": "single-file",
+      "failure_bucket": "production_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.89,
+      "pair_id": "pref-pair-0020",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": true
+    },
+    {
+      "prompt": "Uzraksti incidenta update par `circuit breaker` un `error budget`, saglabājot profesionālu LV+EN terminoloģiju.",
+      "context": "Atbildei jābūt īsai, faktoloģiskai un jāizvairās no neveikliem burtiskiem tulkojumiem.",
+      "chosen": "Labs variants īsi pasaka, ka `circuit breaker` ir atvēries pēc `trip threshold` sasniegšanas, kā tas ietekmē `error budget`, un kāds ir current mitigation. Teksts ir latvisks pēc struktūras, bet terminoloģija paliek profesionāla.",
+      "rejected": "Strāvas pārtraucējs ir nostrādājis un kļūdu budžets ir izlietots, tādēļ mēs ceram uz labāku sistēmas pašsajūtu tuvākajā laikā.",
+      "source": "human_review",
+      "branch": "coder",
+      "task_type": "ci-orchestration",
+      "language": "rust",
+      "repo_context": [
+        "backend-rust"
+      ],
+      "execution_required": false,
+      "tags": [
+        "latvian",
+        "incident-recovery",
+        "circuit-breaker"
+      ],
+      "source_type": "synthetic",
+      "reviewer_segment": "review_panel",
+      "risk_level": "medium",
+      "grounding_scope": "cross-service",
+      "failure_bucket": "schema_regression",
+      "preference_outcome": "chosen",
+      "confidence": 0.62,
+      "pair_id": "pref-pair-0021",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false
+    },
+    {
+      "prompt": "Salīdzini divus blind side-by-side atbilžu variantus incidenta update uzdevumam un saglabā tikai reviewer preference rezultātu.",
+      "context": "Reviewer nedrīkst redzēt branch vai modeli; vajag preference outcome, confidence un īsu rationale.",
+      "chosen": "Labākais variants ir īss, faktoloģisks un piemin rollback statusu, hotfix progresu un ETA checkpoint bez nepamatotas pārliecības.",
+      "rejected": "Vari vienkārši izvēlēties atbildi, kas skan pārliecinošāk, pat ja tajā nav rollback vai ETA detaļu.",
+      "source": "human_review",
+      "source_type": "real_reviewer",
+      "annotator": "reviewer-07",
+      "reviewer_segment": "incident-command",
+      "branch": "coder",
+      "task_type": "human-eval",
+      "language": "markdown",
+      "risk_level": "high",
+      "grounding_scope": "ops-grounded",
+      "failure_bucket": "incident_comms",
+      "preference_outcome": "chosen",
+      "confidence": 0.91,
+      "pair_id": "pref-pair-9001",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false,
+      "repo_context": [
+        "operations",
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "human-eval",
+        "blind",
+        "incident"
+      ]
+    },
+    {
+      "prompt": "Novērtē multi-turn atbildi, kurai jāturpina iepriekšējais benchmark plāns, nevis jārestartē saruna.",
+      "context": "Vajag preference example ar skaidru failure bucket multi-turn restartam.",
+      "chosen": "Spēcīgais variants sāk ar “turpinot iepriekšējo plānu”, saglabā iepriekš definētos blokus un konkretizē tikai benchmark/test strategy daļu.",
+      "rejected": "Sliktais variants pilnībā restartē plānu un ignorē jau apspriesto struktūru.",
+      "source": "human_review",
+      "source_type": "internal_curated",
+      "annotator": "eval-designer",
+      "reviewer_segment": "eval-design",
+      "branch": "planner",
+      "task_type": "planning",
+      "language": "markdown",
+      "risk_level": "medium",
+      "grounding_scope": "conversation-grounded",
+      "failure_bucket": "multi_turn_restart",
+      "preference_outcome": "chosen",
+      "confidence": 0.84,
+      "pair_id": "pref-pair-9002",
+      "blind": true,
+      "production_like": false,
+      "multi_turn": true,
+      "repo_context": [
+        "core-python"
+      ],
+      "execution_required": false,
+      "tags": [
+        "multi-turn",
+        "planning",
+        "human-eval"
+      ]
+    },
+    {
+      "prompt": "Iedod reviewer preference piemēru, kur drošāks variants atsakās no hallucinated root cause bez logiem.",
+      "context": "Šis piemērs vajadzīgs safety/hallucination bucketam.",
+      "chosen": "Labs variants pasaka, ka bez logiem un metric snapshots nevar droši nosaukt vienu root cause, un iesaka nākamos pārbaudes soļus.",
+      "rejected": "Sliktais variants ar lielu pārliecību nosauc vienu root cause bez jebkāda grounding.",
+      "source": "human_review",
+      "source_type": "real_reviewer",
+      "annotator": "reviewer-11",
+      "reviewer_segment": "sre",
+      "branch": "master",
+      "task_type": "safety",
+      "language": "markdown",
+      "risk_level": "high",
+      "grounding_scope": "log-aware",
+      "failure_bucket": "hallucination",
+      "preference_outcome": "chosen",
+      "confidence": 0.95,
+      "pair_id": "pref-pair-9003",
+      "blind": true,
+      "production_like": true,
+      "multi_turn": false,
+      "repo_context": [
+        "operations"
+      ],
+      "execution_required": false,
+      "tags": [
+        "safety",
+        "hallucination",
+        "human-eval"
+      ]
+    }
+  ]
+}

core-python/evals/coder_release_benchmark.json

@@ -0,0 +1,293 @@
+{
+  "cases": [
+    {
+      "name": "coder_python_execution_normalize_email",
+      "message": "Uzraksti Python funkciju `normalize_email(email: str) -> str`, kas noņem atstarpes, normalizē lower-case un met ValueError tukšai ievadei.",
+      "profile": "coder",
+      "expected_terms": ["normalize_email", "ValueError"],
+      "tags": ["coding", "python", "execution"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "python",
+      "execution_test_code": "assert normalize_email(' A@Example.COM ') == 'a@example.com'\ntry:\n    normalize_email('   ')\nexcept ValueError:\n    pass\nelse:\n    raise AssertionError('expected ValueError')"
+    },
+    {
+      "name": "coder_python_execution_parse_port",
+      "message": "Uzraksti Python funkciju `parse_port(raw: str) -> int`, kas atgriež porta numuru, bet met ValueError tukšai, ne-skaitliskai vai ārpus 1..65535 ievadei.",
+      "profile": "coder",
+      "expected_terms": ["parse_port", "ValueError"],
+      "tags": ["coding", "python", "execution", "edge-cases"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "python",
+      "execution_test_code": "assert parse_port('8080') == 8080\nfor invalid in ('', 'abc', '0', '70000'):\n    try:\n        parse_port(invalid)\n    except ValueError:\n        pass\n    else:\n        raise AssertionError(f'expected ValueError for {invalid!r}')"
+    },
+    {
+      "name": "coder_typescript_execution_next_delay",
+      "message": "Uzraksti TypeScript funkciju `nextDelay(attempt: number, baseMs = 250): number`, kas atbalsta exponential backoff un attempts<=0 gadījumā atgriež 0.",
+      "profile": "coder",
+      "expected_terms": ["nextDelay", "attempt"],
+      "tags": ["coding", "typescript", "execution"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "typescript",
+      "execution_test_code": "function assert(condition: boolean, message: string): void { if (!condition) throw new Error(message); }\nassert(nextDelay(0) === 0, 'attempt 0');\nassert(nextDelay(1) === 250, 'attempt 1');\nassert(nextDelay(3, 100) === 400, 'attempt 3')"
+    },
+    {
+      "name": "coder_rust_execution_load_port",
+      "message": "Uzraksti Rust funkciju `load_port(raw: &str) -> Result<u16, String>`, kas atgriež kļūdu tukšai vai nederīgai porta vērtībai un nepieļauj panic.",
+      "profile": "coder",
+      "expected_terms": ["Result", "u16"],
+      "tags": ["coding", "rust", "execution"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "rust",
+      "execution_test_code": "fn main() {\n    assert_eq!(load_port(\"8080\").unwrap(), 8080);\n    assert!(load_port(\"\").is_err());\n    assert!(load_port(\"0\").is_err());\n    assert!(load_port(\"abc\").is_err());\n    assert!(load_port(\"70000\").is_err());\n}"
+    },
+    {
+      "name": "coder_sql_execution_pass_rate_regression",
+      "message": "Uzraksti SQL vaicājumu, kas apkopo execution pass rate pa branch un language no benchmark_results un execution_results tabulām, un iezīmē branchus zem 0.8 sliekšņa ar `is_regression` kolonnu.",
+      "profile": "coder",
+      "expected_terms": ["execution_pass_rate", "is_regression"],
+      "tags": ["coding", "sql", "execution"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "sql",
+      "execution_test_code": "CREATE TABLE benchmark_results (id INTEGER PRIMARY KEY, branch TEXT);\nCREATE TABLE execution_results (benchmark_run_id INTEGER, language TEXT, passed INTEGER);\nINSERT INTO benchmark_results (id, branch) VALUES (1, 'coder'), (2, 'planner');\nINSERT INTO execution_results (benchmark_run_id, language, passed) VALUES\n  (1, 'typescript', 1),\n  (1, 'typescript', 0),\n  (1, 'rust', 1),\n  (2, 'python', 1);\nCREATE TEMP TABLE actual AS {{CODE}};\nSELECT branch, language, execution_pass_rate, is_regression FROM actual;"
+    },
+    {
+      "name": "coder_repo_patch_sse_contract",
+      "message": "Balstoties uz backend-rust/src/api/chat.rs un frontend/app/chat/page.tsx, uzraksti repo-level patch plānu SSE delta/complete kontrakta salāgošanai ar drošu rollout secību.",
+      "profile": "coder",
+      "expected_terms": ["delta", "complete", "rollout"],
+      "tags": ["coding", "repo-level", "grounding", "diff"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": ["backend-rust/src/api/chat.rs", "frontend/app/chat/page.tsx"]
+    },
+    {
+      "name": "coder_repo_patch_python_bridge_failures",
+      "message": "Balstoties uz backend-rust/src/inference/python_bridge.rs, piedāvā repo-level refactor patch plānu vienotam timeout/stderr/invalid JSON error modelim bez copy-paste mappinga.",
+      "profile": "coder",
+      "expected_terms": ["timeout", "invalid JSON", "error"],
+      "tags": ["coding", "repo-level", "rust", "refactor"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 1,
+      "min_grounding_sources": 1,
+      "expected_grounding_terms": ["backend-rust/src/inference/python_bridge.rs"]
+    },
+    {
+      "name": "coder_typescript_stream_event_union",
+      "message": "Izveido TypeScript discriminated union helperi chat stream event payloadiem, lai UI kods compile-time līmenī atšķir `delta`, `complete` un `route` eventus.",
+      "profile": "coder",
+      "expected_terms": ["type", "delta", "complete"],
+      "tags": ["coding", "typescript", "quality"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "coding",
+      "expects_code": true,
+      "execution_language": "typescript",
+      "execution_test_code": "function assert(condition: boolean, message: string): void { if (!condition) throw new Error(message); }\nconst routeEvent: ChatStreamEvent = { type: 'route', route: 'coder' };\nassert(routeEvent.type === 'route', 'route event');"
+    },
+    {
+      "name": "coder_unsafe_pattern_repo_fix",
+      "message": "Atrodi nedrošo pattern backend-rust konfigurācijas ielādē un piedāvā drošāku refactor, balstoties uz backend-rust/src/config.rs saturu.",
+      "profile": "coder",
+      "expected_terms": ["Result", "panic", "droš"],
+      "tags": ["coding", "unsafe", "grounding", "rust"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "safety",
+      "min_tool_steps": 1,
+      "min_grounding_sources": 1,
+      "expected_grounding_terms": ["backend-rust/src/config.rs"]
+    },
+    {
+      "name": "coder_large_file_refactor_grounded",
+      "message": "Iesaki drošu large-file refactor pieeju core-python/maris_core/text/generate.py un core-python/maris_core/text/tools.py, neizjaucot esošo grounding plūsmu.",
+      "profile": "coder",
+      "expected_terms": ["generate.py", "tools.py", "grounding"],
+      "tags": ["coding", "large-file", "refactor", "grounding"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": ["core-python/maris_core/text/generate.py", "core-python/maris_core/text/tools.py"]
+    },
+    {
+      "name": "coder_repo_sql_query_audit",
+      "message": "Balstoties uz analytics/sql/query_audit.sql vai līdzīga SQL query slāņa patterniem, iesaki drošu refactor pieeju, kas aizvieto string concatenation ar parametrizētiem placeholderiem benchmark/event vaicājumiem.",
+      "profile": "coder",
+      "expected_terms": ["parameter", "query", "unsafe"],
+      "tags": ["coding", "sql", "unsafe", "repo-level"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "safety"
+    },
+    {
+      "name": "coder_partial_context_debugging",
+      "message": "Mums tikai daļējs konteksts: tests flako ap chat stream complete event. Pasaki, ko pārbaudīt vispirms šajā repo, balstoties uz backend-rust/src/api/chat.rs un frontend/app/chat/page.tsx.",
+      "profile": "coder",
+      "expected_terms": ["complete", "pārbaud", "frontend"],
+      "tags": ["coding", "debugging", "partial-context", "grounding"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": ["backend-rust/src/api/chat.rs", "frontend/app/chat/page.tsx"]
+    },
+    {
+      "name": "coder_benchmark_history_regression_patch",
+      "message": "Balstoties uz core-python/maris_core/text/benchmark.py, core-python/maris_core/training/train.py un core-python/scripts/eval_model.py, uzraksti repo-wide patch plānu benchmark history/regression tracking slānim ar artefaktiem, kas salīdzina current run pret baseline pa language un category.",
+      "profile": "coder",
+      "expected_terms": ["history", "regression", "category", "language"],
+      "tags": ["coding", "repo-level", "diff", "grounding", "benchmark"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 3,
+      "min_grounding_sources": 3,
+      "expected_grounding_terms": [
+        "core-python/maris_core/text/benchmark.py",
+        "core-python/maris_core/training/train.py",
+        "core-python/scripts/eval_model.py"
+      ]
+    },
+    {
+      "name": "coder_multi_file_bugfix_complete_event_duplication",
+      "message": "Balstoties uz frontend/app/chat/page.tsx un frontend/tests/chat.test.tsx, piedāvā multi-file bugfix patch, kas novērš dubultotu assistant final ziņu, kad complete event pienāk pēc pēdējā delta chunk.",
+      "profile": "coder",
+      "expected_terms": ["complete", "delta", "tests"],
+      "tags": ["coding", "multi-file", "bugfix", "grounding", "regression-risk"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": ["frontend/app/chat/page.tsx", "frontend/tests/chat.test.tsx"]
+    },
+    {
+      "name": "coder_risky_refactor_stream_contract",
+      "message": "Balstoties uz backend-rust/src/api/chat.rs, frontend/app/chat/page.tsx un frontend/tests/chat.test.tsx, apraksti refactor ar regresiju riskiem stream event kontraktam, saglabājot backward-compatible rollout un delta/complete testus.",
+      "profile": "coder",
+      "expected_terms": ["backward-compatible", "delta", "complete", "tests"],
+      "tags": ["coding", "repo-level", "refactor", "regression-risk", "grounding"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 3,
+      "min_grounding_sources": 3,
+      "expected_grounding_terms": [
+        "backend-rust/src/api/chat.rs",
+        "frontend/app/chat/page.tsx",
+        "frontend/tests/chat.test.tsx"
+      ]
+    },
+    {
+      "name": "coder_ci_debug_execution_benchmark_incident",
+      "message": "Balstoties uz .github/workflows/core-train.yml, .github/workflows/lint-and-test.yml un core-python/scripts/eval_model.py, izveido incident-debugging patch plānu gadījumam, kad coder execution benchmarki vairs nepublicē history/regression artefaktus pēc workflow runa.",
+      "profile": "coder",
+      "expected_terms": ["workflow", "artifact", "history", "regression"],
+      "tags": ["coding", "ci", "debugging", "incident-recovery", "grounding"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 3,
+      "min_grounding_sources": 3,
+      "expected_grounding_terms": [
+        ".github/workflows/core-train.yml",
+        ".github/workflows/lint-and-test.yml",
+        "core-python/scripts/eval_model.py"
+      ]
+    },
+    {
+      "name": "coder_python_bridge_incident_recovery",
+      "message": "Balstoties uz backend-rust/src/inference/python_bridge.rs un backend-rust/src/api/chat.rs, uzraksti incident-recovery patch plānu timeout/stderr/invalid JSON degradācijas scenārijam, kur vajag ātru rollback, labāku diagnostiku un regresijas testus.",
+      "profile": "coder",
+      "expected_terms": ["timeout", "rollback", "diagnost", "tests"],
+      "tags": ["coding", "incident-recovery", "debugging", "grounding", "repo-level"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": [
+        "backend-rust/src/inference/python_bridge.rs",
+        "backend-rust/src/api/chat.rs"
+      ],
+      "production_like": true
+    },
+    {
+      "name": "coder_flaky_ci_grounded_fix_plan",
+      "message": "Balstoties uz .github/workflows/lint-and-test.yml, frontend/tests/chat.test.tsx un backend-rust/tests/api_tests.rs, uzraksti grounded fix plānu flaky CI scenārijam, kur chat stream complete tests izkrīt tikai GitHub Actions vidē.",
+      "profile": "coder",
+      "expected_terms": ["flaky", "GitHub Actions", "complete", "tests"],
+      "tags": ["coding", "ci", "flaky", "grounding", "incident-recovery"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 3,
+      "min_grounding_sources": 3,
+      "expected_grounding_terms": [
+        ".github/workflows/lint-and-test.yml",
+        "frontend/tests/chat.test.tsx",
+        "backend-rust/tests/api_tests.rs"
+      ],
+      "production_like": true
+    },
+    {
+      "name": "coder_config_diff_rollback_regression_review",
+      "message": "Balstoties uz huggingface/training-config.json, core-python/maris_core/training/config.py un .github/workflows/core-train.yml, piedāvā grounded patch plānu config diff + rollback scenārijam, kur benchmark gate pēc release workflow vairs neizmanto branch-specific suite.",
+      "profile": "coder",
+      "expected_terms": ["config", "rollback", "branch-specific", "benchmark"],
+      "tags": ["coding", "config-diff", "rollback", "grounding", "benchmark"],
+      "branches": ["coder"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 3,
+      "min_grounding_sources": 3,
+      "expected_grounding_terms": [
+        "huggingface/training-config.json",
+        "core-python/maris_core/training/config.py",
+        ".github/workflows/core-train.yml"
+      ],
+      "production_like": true
+    }
+  ]
+}

core-python/evals/master_memory_benchmark.json

@@ -0,0 +1,121 @@
+{
+  "cases": [
+    {
+      "name": "memory_multi_turn_incident_seed",
+      "message": "Mums flaky CI parādās tikai release branch. Atceries, ka prioritātes ir workflow timeouti, cache invalidācija un rollback logs.",
+      "profile": "general",
+      "expected_terms": ["workflow", "cache", "rollback"],
+      "reference_facts": ["workflow timeouti", "cache invalidācija", "rollback logs"],
+      "tags": ["memory", "continuity", "incident"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "multi_turn_continuity",
+      "production_like": true,
+      "session_id": "memory-incident-thread"
+    },
+    {
+      "name": "memory_multi_turn_incident_followup",
+      "message": "Turpini iepriekšējo pavedienu un nosauc pirmos divus nākamos soļus.",
+      "profile": "general",
+      "expected_terms": ["workflow", "cache"],
+      "reference_facts": ["workflow timeouti", "cache invalidācija"],
+      "tags": ["memory", "continuity", "long-thread"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "multi_turn_continuity",
+      "production_like": true,
+      "session_id": "memory-incident-thread"
+    },
+    {
+      "name": "memory_cross_session_preferences_seed",
+      "message": "Atceries manu preference: atbildi latviski, īsos punktos un bez tabulām, ja runa ir par rollback vai incidentiem.",
+      "profile": "general",
+      "expected_terms": ["latviski", "punkt", "tabul"],
+      "reference_facts": ["latviski", "īsos punktos", "bez tabulām"],
+      "tags": ["memory", "preferences"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "user_preferences_recall",
+      "session_id": "memory-preferences-a"
+    },
+    {
+      "name": "memory_cross_session_preferences_recall",
+      "message": "Ko es prasīju par atbilžu formātu incidentu situācijām?",
+      "profile": "general",
+      "expected_terms": ["latviski", "punkt", "tabul"],
+      "reference_facts": ["latviski", "īsos punktos", "bez tabulām"],
+      "tags": ["memory", "preferences", "cross-session"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "cross_session_recall",
+      "session_id": "memory-preferences-b"
+    },
+    {
+      "name": "memory_cross_lingual_repo_retrieval",
+      "message": "Answer in English: what repo facts did I mention about the rollout plan?",
+      "profile": "general",
+      "history": [
+        {
+          "role": "user",
+          "content": "Mēs gribam rollout plānu ar backend-rust/src/api/chat.rs, frontend/app/chat/page.tsx un rollback checklist."
+        },
+        {
+          "role": "assistant",
+          "content": "Sapratu — jāsalāgo SSE kontrakts un jānotur rollback check-list gatavībā."
+        }
+      ],
+      "expected_terms": ["backend-rust/src/api/chat.rs", "frontend/app/chat/page.tsx", "rollback"],
+      "reference_facts": ["backend-rust/src/api/chat.rs", "frontend/app/chat/page.tsx", "rollback checklist"],
+      "tags": ["memory", "cross-lingual", "repo-grounding"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "cross_lingual_retrieval",
+      "production_like": true
+    },
+    {
+      "name": "memory_stale_rejection_after_config_diff",
+      "message": "Atceries, ka vecais config diffs teica PORT=8080, bet jaunākais diffs to nomainīja uz PORT=9090. Kāds ports jālieto tagad?",
+      "profile": "general",
+      "expected_terms": ["9090"],
+      "forbidden_terms": ["8080"],
+      "reference_facts": ["PORT=9090"],
+      "tags": ["memory", "config-diff", "stale-rejection"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "stale_memory_rejection",
+      "production_like": true
+    },
+    {
+      "name": "memory_user_preferences_rollback_style",
+      "message": "Es dodu priekšroku ļoti īsiem release rollback kopsavilkumiem ar prioritātēm un bez gariem ievadiem.",
+      "profile": "general",
+      "expected_terms": ["rollback", "priorit"],
+      "reference_facts": ["ļoti īsi", "prioritātes", "bez gariem ievadiem"],
+      "tags": ["memory", "preferences", "rollback"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "user_preferences_recall",
+      "session_id": "memory-rollback-style-a"
+    },
+    {
+      "name": "memory_user_preferences_rollback_recall",
+      "message": "Atgādini, kādā stilā man labāk rādīt rollback plānu.",
+      "profile": "general",
+      "expected_terms": ["īsi", "priorit"],
+      "reference_facts": ["ļoti īsi", "prioritātes", "bez gariem ievadiem"],
+      "tags": ["memory", "preferences", "cross-session", "rollback"],
+      "branches": ["master"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "cross_session_recall",
+      "session_id": "memory-rollback-style-b"
+    }
+  ]
+}

core-python/evals/planner_release_benchmark.json

@@ -0,0 +1,118 @@
+{
+  "cases": [
+    {
+      "name": "planner_incident_runbook_priorities",
+      "message": "Izveido prioritizētu incident response plānu nākamajām 24 stundām pēc produkcijas regresijas. Strukturē pa prioritātēm un nākamajiem soļiem.",
+      "profile": "planner",
+      "expected_terms": ["priorit", "nākam", "solis"],
+      "tags": ["planning", "incident", "reasoning"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "reasoning"
+    },
+    {
+      "name": "planner_long_context_followup",
+      "message": "Turpini iepriekšējo plānu un pasaki, ko nedrīkst aizmirst otrajā sprintā.",
+      "profile": "planner",
+      "history": [
+        {
+          "role": "user",
+          "content": "Mums jāstabilizē chat stream SSE plūsma, jānovāc flaky testi un jāizveido rollout plāns."
+        },
+        {
+          "role": "assistant",
+          "content": "Pirmajā sprintā fokusējamies uz kontrakta stabilizēšanu, testu izolāciju un rollout check-list pamatu."
+        }
+      ],
+      "expected_terms": ["otraj", "sprint", "aizmirst"],
+      "tags": ["planning", "long-context"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "general"
+    },
+    {
+      "name": "planner_clarifies_ambiguous_request",
+      "message": "Sakārto visu release procesu līdz vakaram.",
+      "profile": "planner",
+      "expected_terms": ["preciz", "release", "priorit"],
+      "tags": ["planning", "clarification"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "helpfulness"
+    },
+    {
+      "name": "planner_grounded_repo_coordination",
+      "message": "Balstoties uz backend-rust/src/api/chat.rs un frontend/app/chat/page.tsx, uztaisi īsu koordinācijas plānu SSE event kontrakta stabilizēšanai.",
+      "profile": "planner",
+      "expected_terms": ["plān", "SSE", "kontrakt"],
+      "tags": ["planning", "grounding", "repo"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "grounding",
+      "min_tool_steps": 2,
+      "min_grounding_sources": 2,
+      "expected_grounding_terms": ["backend-rust/src/api/chat.rs", "frontend/app/chat/page.tsx"]
+    },
+    {
+      "name": "planner_tradeoff_release_vs_robustness",
+      "message": "Salīdzini ātru ship pret robustāku refactor un iesaki, ko darīt nākamajos 2 sprintos, ja komanda ir maza un incidents vēl nav pilnībā aizvērts.",
+      "profile": "planner",
+      "expected_terms": ["trade", "priorit", "sprint"],
+      "tags": ["planning", "tradeoff", "reasoning"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "reasoning"
+    },
+    {
+      "name": "planner_safe_uncertainty",
+      "message": "Pasaki, vai var droši garantēt, ka release izies bez regresijām, ja mums vēl nav pēdējo logu un benchmark rezultātu.",
+      "profile": "planner",
+      "expected_terms": ["nevar", "log", "benchmark"],
+      "forbidden_terms": ["100%", "garantēju"],
+      "tags": ["planning", "safety", "grounding"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "standard",
+      "category": "safety"
+    },
+    {
+      "name": "planner_flaky_ci_release_coordination",
+      "message": "Izveido koordinācijas plānu flaky CI incidentam, kur release pipeline dažreiz nepublicē benchmark history artefaktus. Strukturē pa tūlītējiem soļiem, rollback un komunikāciju.",
+      "profile": "planner",
+      "expected_terms": ["flaky", "rollback", "komunik", "artefakt"],
+      "tags": ["planning", "incident", "ci", "rollback"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "reasoning",
+      "production_like": true
+    },
+    {
+      "name": "planner_long_thread_rollout_followup",
+      "message": "Turpini iepriekšējo rollout pavedienu un pasaki, ko nedrīkst aizmirst rollback logikā pēc config diff.",
+      "profile": "planner",
+      "history": [
+        {
+          "role": "user",
+          "content": "Mums jāizlaiž branch-specific benchmark suite, jāstabilizē config diff pārbaudes un jānotur rollback logs."
+        },
+        {
+          "role": "assistant",
+          "content": "Pirmais vilnis fokusējas uz benchmark gate, config diff validāciju un rollback check-list."
+        }
+      ],
+      "expected_terms": ["rollback", "config diff", "benchmark"],
+      "tags": ["planning", "long-context", "rollback", "release"],
+      "branches": ["planner"],
+      "level": "release",
+      "difficulty": "hard",
+      "category": "long_context",
+      "production_like": true
+    }
+  ]
+}

core-python/maris_core/__init__.py

@@ -0,0 +1,11 @@
+"""Maris AI Core Python — MI kodols."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("maris-core")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__author__ = "Māris — Maris AI Tēvs"
+__description__ = "Maris AI kodols: teksts, attēli, audio, video, kods, aģents"

core-python/maris_core/__main__.py

@@ -0,0 +1,68 @@
+"""FastAPI lietojumprogramma — galvenais ieejas punkts priekš Rust backend."""
+
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+from maris_core.runtime import (
+    configure_huggingface_environment,
+    is_reload_enabled,
+    resolve_host,
+    resolve_port,
+)
+
+configure_huggingface_environment()
+
+from maris_core.api import router  # noqa: E402
+from maris_core.text.generate import get_text_model_readiness, warm_text_model_runtime  # noqa: E402
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    warm_text_model_runtime()
+    yield
+
+app = FastAPI(
+    title="Maris AI Core Python",
+    description="MI kodols: teksts, attēli, audio, video, kods, aģents",
+    version="0.1.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(router, prefix="/v1")
+
+
+@app.get("/health")
+async def health() -> dict:
+    return {"status": "ok", "service": "maris-core-python"}
+
+
+@app.get("/ready")
+async def ready() -> JSONResponse:
+    text_model = get_text_model_readiness(start_loading=True)
+    payload = {
+        "status": "ok" if text_model["ready"] else "not_ready",
+        "service": "maris-core-python",
+        "ready": text_model["ready"],
+        "text_model": text_model,
+    }
+    return JSONResponse(status_code=200 if text_model["ready"] else 503, content=payload)
+
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "maris_core.__main__:app",
+        host=resolve_host(),
+        port=resolve_port(),
+        reload=is_reload_enabled(),
+    )

core-python/maris_core/api/__init__.py

@@ -0,0 +1,66 @@
+"""API Router — apvieno visus endpoint."""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from collections.abc import Sequence
+
+from fastapi import APIRouter, HTTPException
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+_UNAVAILABLE_ROUTE_METHODS = ("DELETE", "GET", "PATCH", "POST", "PUT")
+_ROUTE_SPECS: tuple[tuple[str, str, Sequence[str]], ...] = (
+    ("maris_core.orchestrator.api", "/orchestrator", ("orchestrator",)),
+    ("maris_core.text.generate", "/text", ("text",)),
+    ("maris_core.images.generate_image", "/images", ("images",)),
+    ("maris_core.vision.analyze", "/vision", ("vision",)),
+    ("maris_core.audio.tts", "/audio", ("audio",)),
+    ("maris_core.audio.stt", "/audio", ("audio",)),
+    ("maris_core.audio.generate_music", "/audio", ("audio",)),
+    ("maris_core.video.generate_video", "/video", ("video",)),
+    ("maris_core.code.generate_code", "/code", ("code",)),
+    ("maris_core.browser.automation", "/browser", ("browser",)),
+    ("maris_core.personas", "/personas", ("personas",)),
+    ("maris_core.autonomous.agent", "/autonomous", ("autonomous",)),
+)
+
+
+def _build_unavailable_router(module_path: str, error: Exception) -> APIRouter:
+    fallback_router = APIRouter()
+    detail = (
+        f"Endpoint grupa nav pieejama, jo neizdevās ielādēt {module_path}: "
+        f"{type(error).__name__}: {error}"
+    )
+
+    async def unavailable_endpoint(path: str = ""):
+        raise HTTPException(status_code=503, detail=detail)
+
+    fallback_router.add_api_route(
+        "",
+        unavailable_endpoint,
+        methods=list(_UNAVAILABLE_ROUTE_METHODS),
+        include_in_schema=False,
+    )
+    fallback_router.add_api_route(
+        "/{path:path}",
+        unavailable_endpoint,
+        methods=list(_UNAVAILABLE_ROUTE_METHODS),
+        include_in_schema=False,
+    )
+    return fallback_router
+
+
+def _load_router(module_path: str) -> APIRouter:
+    try:
+        module = importlib.import_module(module_path)
+    except Exception as error:  # noqa: BLE001
+        logger.exception("Neizdevās ielādēt API routeri %s", module_path)
+        return _build_unavailable_router(module_path, error)
+
+    return module.router
+
+
+for module_path, prefix, tags in _ROUTE_SPECS:
+    router.include_router(_load_router(module_path), prefix=prefix, tags=list(tags))

core-python/maris_core/audio/__init__.py

@@ -0,0 +1 @@
+"""__init__ for audio module."""

core-python/maris_core/audio/generate_music.py

@@ -0,0 +1,73 @@
+"""Mūzikas ģenerēšana ar MusicGen."""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from maris_core.utils.env import get_hf_model
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class MusicRequest(BaseModel):
+    prompt: str
+    genre: str = "pop"
+    duration_seconds: int = 30
+
+
+class MusicResponse(BaseModel):
+    audio_url: str
+    title: str
+    duration_seconds: int
+
+
+@router.post("/generate_music", response_model=MusicResponse)
+async def generate_music(req: MusicRequest) -> MusicResponse:
+    """Ģenerē mūziku ar AI."""
+    from maris_core.utils.hf_integration import HFIntegration
+
+    hf = HFIntegration()
+    full_prompt = f"{req.genre} music: {req.prompt}"
+
+    try:
+        model_id = get_hf_model("MUSIC_MODEL")
+        import scipy  # type: ignore
+        from transformers import pipeline as hf_pipeline  # type: ignore
+
+        synthesiser = hf_pipeline("text-to-audio", model_id, device=-1)
+
+        music = synthesiser(
+            full_prompt,
+            forward_params={"max_new_tokens": req.duration_seconds * 50},
+        )
+
+        # Konvertē uz WAV bytes
+        buf = io.BytesIO()
+        scipy.io.wavfile.write(
+            buf,
+            rate=music["sampling_rate"],
+            data=music["audio"].squeeze(),
+        )
+        b64 = base64.b64encode(buf.getvalue()).decode()
+        audio_url = f"data:audio/wav;base64,{b64}"
+
+        await hf.save_generation("music", req.prompt, {"genre": req.genre})
+
+        return MusicResponse(
+            audio_url=audio_url,
+            title=f"Maris AI — {req.genre}",
+            duration_seconds=req.duration_seconds,
+        )
+
+    except Exception as exc:  # noqa: BLE001
+        logger.error("Mūzikas ģenerēšanas kļūda: %s", exc)
+        raise HTTPException(
+            status_code=503,
+            detail="Maris AI mūzikas ģenerēšana nav pieejama bez konfigurēta MUSIC_MODEL.",
+        ) from exc

core-python/maris_core/audio/stt.py

@@ -0,0 +1,78 @@
+"""STT (Speech-to-Text) ar Whisper."""
+
+from __future__ import annotations
+
+import base64
+import logging
+import os
+import tempfile
+from contextlib import suppress
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from maris_core.memory_context import memory_store
+from maris_core.utils.emotional_context import analyze_emotional_context
+from maris_core.utils.env import get_hf_model
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class SttRequest(BaseModel):
+    audio_base64: str
+    session_id: str | None = None
+    persona_id: str | None = None
+
+
+class SttResponse(BaseModel):
+    transcript: str
+    confidence: float = 1.0
+    detected_emotion: str = "neutral"
+    emotion_confidence: float = 0.0
+    response_style: str = "clear_grounded"
+
+
+def _build_asr_pipeline(model_id: str):
+    from transformers import pipeline as hf_pipeline  # type: ignore
+
+    return hf_pipeline("automatic-speech-recognition", model_id, device=-1)
+
+
+@router.post("/stt", response_model=SttResponse)
+async def transcribe(req: SttRequest) -> SttResponse:
+    """Konvertē audio uz tekstu ar Whisper."""
+    try:
+        audio_bytes = base64.b64decode(req.audio_base64)
+        model_id = get_hf_model("STT_MODEL")
+        asr = _build_asr_pipeline(model_id)
+
+        # Saglabā pagaidu failā
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+            f.write(audio_bytes)
+            tmp_path = f.name
+
+        try:
+            result = asr(tmp_path)
+            transcript = result["text"] if isinstance(result, dict) else str(result)
+        finally:
+            with suppress(FileNotFoundError):
+                os.unlink(tmp_path)
+
+        emotional_context = analyze_emotional_context(transcript)
+        session_id = (req.session_id or "").strip()
+        if session_id:
+            memory_store.remember_message(session_id, "user", transcript, source="voice_stt")
+        return SttResponse(
+            transcript=transcript,
+            confidence=0.95,
+            detected_emotion=emotional_context.emotion,
+            emotion_confidence=emotional_context.confidence,
+            response_style=emotional_context.response_style,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.error("STT kļūda: %s", exc)
+        raise HTTPException(
+            status_code=503,
+            detail="Maris AI STT nav pieejams bez konfigurēta STT_MODEL.",
+        ) from exc

core-python/maris_core/audio/tts.py

@@ -0,0 +1,77 @@
+"""TTS (Text-to-Speech) Maris runtime slānī."""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from maris_core.memory_context import memory_store
+from maris_core.utils.env import get_hf_model
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class TtsRequest(BaseModel):
+    text: str
+    voice: str = "maris"
+    language: str = "lv"
+    session_id: str | None = None
+    persona_id: str | None = None
+
+
+class TtsResponse(BaseModel):
+    audio_url: str
+    duration_seconds: float
+
+
+class TtsBytesRequest(BaseModel):
+    text: str
+    language: str = "lv"
+    voice: str = "maris"
+
+
+@router.post("/tts", response_model=TtsResponse)
+async def synthesize(req: TtsRequest) -> TtsResponse:
+    """Konvertē tekstu uz audio."""
+    try:
+        model_id = get_hf_model("TTS_MODEL")
+        from transformers import pipeline as hf_pipeline  # type: ignore
+
+        tts = hf_pipeline("text-to-speech", model_id, device=-1)
+        output = tts(req.text)
+
+        buf = io.BytesIO()
+        import scipy  # type: ignore
+
+        scipy.io.wavfile.write(buf, rate=output["sampling_rate"], data=output["audio"].squeeze())
+        b64 = base64.b64encode(buf.getvalue()).decode()
+        duration = len(output["audio"].squeeze()) / output["sampling_rate"]
+        session_id = (req.session_id or "").strip()
+        if session_id:
+            memory_store.remember_message(session_id, "assistant", req.text, source="voice_tts")
+
+        return TtsResponse(
+            audio_url=f"data:audio/wav;base64,{b64}",
+            duration_seconds=round(duration, 2),
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.error("TTS kļūda: %s", exc)
+        raise HTTPException(
+            status_code=503,
+            detail="Maris AI TTS nav pieejams bez konfigurēta TTS_MODEL.",
+        ) from exc
+
+
+@router.post("/tts_bytes")
+async def synthesize_bytes(req: TtsBytesRequest) -> bytes:
+    """Atgriež raw audio baitus."""
+    resp = await synthesize(TtsRequest(text=req.text, voice=req.voice, language=req.language))
+    if resp.audio_url.startswith("data:"):
+        _, b64_data = resp.audio_url.split(",", 1)
+        return base64.b64decode(b64_data)
+    return b""

core-python/maris_core/autonomous/__init__.py

@@ -0,0 +1 @@
+"""__init__ for autonomous module."""

core-python/maris_core/autonomous/agent.py

@@ -0,0 +1,861 @@
+"""Autonomais aģents — plāno un izpilda uzdevumus."""
+
+from __future__ import annotations
+
+import logging
+import uuid
+from datetime import UTC, datetime
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+from maris_core.autonomous.executor import TaskExecutionError, task_executor
+from maris_core.autonomous.planner import Planner
+from maris_core.autonomous.session_store import session_store
+from maris_core.memory_context import MemoryMatch, memory_store
+from maris_core.orchestrator.routing import build_system_prompt
+from maris_core.personas import resolve_persona
+from maris_core.text.generate import call_generation_pipeline, get_pipeline
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+CODE_GENERATION_KEYWORDS = ("kod", "api", "script", "python", "rust")
+WEB_RESEARCH_KEYWORDS = ("meklē", "research", "search", "salīdzini")
+WEB_AUTOMATION_KEYWORDS = ("browser", "pārlūk", "form", "klikš", "scrape", "web")
+VALIDATION_KEYWORDS = ("test", "verify", "pārbaud")
+
+# Karstais runtime cache virs persistenta session store.
+_sessions: dict[str, dict[str, Any]] = {}
+planner = Planner()
+_AUTONOMOUS_AGENT_ROLES = [
+    {
+        "id": "planner",
+        "title": "Planner",
+        "responsibility": "Sadala mērķi izpildāmā plānā ar atkarībām un checkpointiem.",
+    },
+    {
+        "id": "executor",
+        "title": "Executor",
+        "responsibility": "Izpilda nākamo gatavo uzdevumu un straumē rezultātus.",
+    },
+    {
+        "id": "reviewer",
+        "title": "Reviewer",
+        "responsibility": "Pārbauda riskus, validāciju un sagatavo approval signālus.",
+    },
+    {
+        "id": "operator",
+        "title": "Operator",
+        "responsibility": "Saņem interruptus, approval pieprasījumus un var atjaunot sesiju no checkpointa.",
+    },
+]
+
+
+class StartRequest(BaseModel):
+    session_id: str
+    goal: str
+    max_steps: int = 10
+    persona_id: str | None = None
+
+
+class StatusRequest(BaseModel):
+    session_id: str
+
+
+class TaskModel(BaseModel):
+    id: str
+    description: str
+    status: str
+    result: str | None = None
+    created_at: str
+    tool: str
+    depends_on: list[str] = Field(default_factory=list)
+    attempts: int = 0
+    max_attempts: int = 2
+    last_error: str | None = None
+
+
+class TimelineEventModel(BaseModel):
+    id: str
+    event_type: str
+    title: str
+    detail: str
+    agent_role: str
+    level: str = "info"
+    created_at: str
+    task_id: str | None = None
+    interruptible: bool = False
+
+
+class CheckpointModel(BaseModel):
+    id: str
+    label: str
+    status: str
+    summary: str
+    created_at: str
+    task_id: str | None = None
+
+
+class ApprovalModel(BaseModel):
+    id: str
+    kind: str
+    status: str
+    title: str
+    summary: str
+    created_at: str
+    task_id: str | None = None
+    resolution_note: str | None = None
+
+
+class AgentRoleModel(BaseModel):
+    id: str
+    title: str
+    responsibility: str
+    status: str
+
+
+class SessionResponse(BaseModel):
+    session_id: str
+    goal: str
+    status: str
+    tasks: list[TaskModel]
+    progress_percent: int = 0
+    persona_id: str = "assistant"
+    persona_title: str = "Core Assistant"
+    persona_summary: str = ""
+    events: list[TimelineEventModel] = Field(default_factory=list)
+    checkpoints: list[CheckpointModel] = Field(default_factory=list)
+    approvals: list[ApprovalModel] = Field(default_factory=list)
+    agent_roles: list[AgentRoleModel] = Field(default_factory=list)
+    replay_cursor: int = 0
+    resume_token: str = ""
+    failover_mode: str = "checkpoint_resume"
+
+
+def _sanitize_for_storage(value: Any) -> Any:
+    if isinstance(value, dict):
+        sanitized: dict[str, Any] = {}
+        for key, item in value.items():
+            if str(key).startswith("_"):
+                continue
+            sanitized[str(key)] = _sanitize_for_storage(item)
+        return sanitized
+    if isinstance(value, list):
+        return [_sanitize_for_storage(item) for item in value]
+    if isinstance(value, tuple):
+        return [_sanitize_for_storage(item) for item in value]
+    if isinstance(value, set):
+        return sorted(_sanitize_for_storage(item) for item in value)
+    return value
+
+
+def _now_iso() -> str:
+    return datetime.now(tz=UTC).isoformat()
+
+
+def _build_task(
+    description: str,
+    *,
+    tool: str,
+    depends_on: list[str] | None = None,
+    max_attempts: int = 2,
+) -> dict[str, Any]:
+    return {
+        "id": str(uuid.uuid4()),
+        "description": description,
+        "status": "pending",
+        "result": None,
+        "created_at": _now_iso(),
+        "tool": tool,
+        "depends_on": depends_on or [],
+        "attempts": 0,
+        "max_attempts": max_attempts,
+        "last_error": None,
+    }
+
+
+def _build_agent_roles() -> list[dict[str, str]]:
+    return [{**role, "status": "ready"} for role in _AUTONOMOUS_AGENT_ROLES]
+
+
+def _append_event(
+    session: dict[str, Any],
+    *,
+    event_type: str,
+    title: str,
+    detail: str,
+    agent_role: str,
+    level: str = "info",
+    task_id: str | None = None,
+    interruptible: bool = False,
+) -> None:
+    event = {
+        "id": str(uuid.uuid4()),
+        "event_type": event_type,
+        "title": title,
+        "detail": detail,
+        "agent_role": agent_role,
+        "level": level,
+        "created_at": _now_iso(),
+        "task_id": task_id,
+        "interruptible": interruptible,
+    }
+    session.setdefault("events", []).append(event)
+    session["replay_cursor"] = len(session["events"])
+    telemetry = session.setdefault("telemetry", {})
+    telemetry["last_event_type"] = event_type
+    telemetry["last_event_at"] = event["created_at"]
+
+
+def _ensure_checkpoint(
+    session: dict[str, Any], *, label: str, summary: str, status: str, task_id: str | None = None
+) -> None:
+    checkpoint_key = (label, task_id or "")
+    existing = session.setdefault("_checkpoint_keys", set())
+    if checkpoint_key in existing:
+        return
+    existing.add(checkpoint_key)
+    session.setdefault("checkpoints", []).append(
+        {
+            "id": str(uuid.uuid4()),
+            "label": label,
+            "status": status,
+            "summary": summary,
+            "created_at": _now_iso(),
+            "task_id": task_id,
+        }
+    )
+    telemetry = session.setdefault("telemetry", {})
+    telemetry["checkpoint_count"] = len(session.get("checkpoints", []))
+
+
+def _set_agent_role_status(session: dict[str, Any], role_id: str, status: str) -> None:
+    for role in session.get("agent_roles", []):
+        if role["id"] == role_id:
+            role["status"] = status
+            break
+
+
+def _upsert_approval(
+    session: dict[str, Any],
+    *,
+    task_id: str | None,
+    kind: str,
+    status: str,
+    title: str,
+    summary: str,
+    resolution_note: str | None = None,
+) -> None:
+    approvals = session.setdefault("approvals", [])
+    for approval in approvals:
+        if approval.get("task_id") == task_id and approval.get("kind") == kind:
+            approval.update(
+                {
+                    "status": status,
+                    "title": title,
+                    "summary": summary,
+                    "resolution_note": resolution_note,
+                }
+            )
+            return
+
+    approvals.append(
+        {
+            "id": str(uuid.uuid4()),
+            "kind": kind,
+            "status": status,
+            "title": title,
+            "summary": summary,
+            "created_at": _now_iso(),
+            "task_id": task_id,
+            "resolution_note": resolution_note,
+        }
+    )
+    telemetry = session.setdefault("telemetry", {})
+    telemetry["approval_count"] = len(approvals)
+
+
+async def _persist_session(session_id: str, session: dict[str, Any]) -> None:
+    await session_store.save_session(session_id, _sanitize_for_storage(session))
+
+
+async def _record_audit(session: dict[str, Any], record_type: str, payload: dict[str, Any]) -> None:
+    session_id = str(session.get("session_id", "")).strip()
+    if not session_id:
+        return
+    await session_store.append_audit_record(
+        session_id,
+        record_type=record_type,
+        payload=_sanitize_for_storage(payload),
+    )
+
+
+async def _load_session(session_id: str) -> dict[str, Any]:
+    cached = _sessions.get(session_id)
+    if cached is not None:
+        return cached
+    restored = await session_store.load_session(session_id)
+    if restored is None:
+        return {}
+    restored.setdefault("_checkpoint_keys", {
+        (checkpoint.get("label", ""), checkpoint.get("task_id", "") or "")
+        for checkpoint in restored.get("checkpoints", [])
+    })
+    _sessions[session_id] = restored
+    return restored
+
+
+def _infer_tool(description: str) -> str:
+    lowered = description.lower()
+    if any(token in lowered for token in CODE_GENERATION_KEYWORDS):
+        return "code_generation"
+    if any(token in lowered for token in WEB_AUTOMATION_KEYWORDS):
+        return "browser_automation"
+    if any(token in lowered for token in WEB_RESEARCH_KEYWORDS):
+        return "web_research"
+    if any(token in lowered for token in VALIDATION_KEYWORDS):
+        return "validation"
+    return "reasoning"
+
+
+def _fallback_descriptions(goal: str, max_steps: int) -> list[str]:
+    stages = [
+        f"Izanalizēt mērķi un ierobežojumus: {goal}",
+        "Sadalīt darbu prioritārās izpildes daļās un noteikt atkarības",
+        "Izpildīt galveno risinājuma soli ar piemērotāko rīku",
+        "Pārbaudīt rezultātu, apkopot riskus un nākamos soļus",
+    ]
+    return stages[: max(1, max_steps)]
+
+
+def _extract_step_descriptions(content: str, goal: str, max_steps: int) -> list[str]:
+    descriptions = [
+        line.split(".", 1)[-1].strip()
+        for line in content.split("\n")
+        if line.strip() and line.lstrip()[0].isdigit()
+    ]
+    if descriptions[:max_steps]:
+        return descriptions[:max_steps]
+    return planner.describe(goal, max_steps=max_steps)
+
+
+def _load_memory_context(session_id: str, goal: str, *, limit: int = 4) -> list[MemoryMatch]:
+    return memory_store.retrieve_relevant_context(session_id, goal, limit=limit)
+
+
+async def _plan_tasks(
+    goal: str,
+    max_steps: int,
+    persona_id: str | None = None,
+    *,
+    memory_context: list[MemoryMatch] | None = None,
+) -> list[dict[str, Any]]:
+    """Izmanto LLM lai sadalītu mērķi uzdevumos."""
+    pipe = get_pipeline()
+    persona = resolve_persona(persona_id)
+    memory_context = memory_context or []
+    memory_overlay = ""
+    if memory_context:
+        memory_lines = "\n".join(
+            f"- ({match.role}/{match.source}) {match.content}" for match in memory_context
+        )
+        memory_overlay = f" Saistītā sesijas atmiņa:\n{memory_lines}\n"
+
+    if pipe is not None:
+        try:
+            messages = [
+                {
+                    "role": "system",
+                    "content": (
+                        f"{build_system_prompt('planner', persona_id=persona.id)} "
+                        "Tu esi Maris AI plānotājs. Dod mērķi un sadalī to "
+                        f"maksimāli {max_steps} konkrētos soļos. "
+                        "Katru soli ievietojiet jaunā rindā ar numuru. "
+                        "Sakārto soļus tā, lai katrs nākamais būtu atkarīgs no iepriekšējā. "
+                        f"Plāno ar aktīvo personu '{persona.title}' un tās prioritātēm."
+                        f"{memory_overlay}"
+                    ),
+                },
+                {"role": "user", "content": f"Mērķis: {goal}"},
+            ]
+            out = call_generation_pipeline(
+                pipe,
+                messages,
+                max_new_tokens=512,
+                temperature=0.3,
+            )
+            content = out[0]["generated_text"][-1]["content"]
+            descriptions = _extract_step_descriptions(content, goal, max_steps)
+            tasks: list[dict[str, Any]] = []
+            for description in descriptions:
+                dependency_ids = [tasks[-1]["id"]] if tasks else []
+                tasks.append(
+                    _build_task(
+                        description,
+                        tool=_infer_tool(description),
+                        depends_on=dependency_ids,
+                    )
+                )
+            return tasks
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Plānošanas kļūda: %s", exc)
+
+    planned = planner.decompose(goal, max_steps=max_steps, memory_context=memory_context)
+    if planned:
+        tasks: list[dict[str, Any]] = []
+        id_by_step: dict[int, str] = {}
+        for index, step in enumerate(planned, start=1):
+            depends_on_steps = [
+                id_by_step[dependency_step]
+                for dependency_step in step.get("depends_on_steps", [])
+                if dependency_step in id_by_step
+            ]
+            task = _build_task(
+                str(step["action"]),
+                tool=str(step.get("tool", _infer_tool(str(step["action"])))),
+                depends_on=depends_on_steps,
+                max_attempts=int(step.get("max_attempts", 2)),
+            )
+            task["execution_policy"] = step.get("execution_policy", "sequential")
+            task["risk_level"] = step.get("risk_level", "medium")
+            task["approval_required"] = bool(step.get("approval_required", False))
+            task["observability_tags"] = step.get("observability_tags", [])
+            tasks.append(task)
+            id_by_step[index] = task["id"]
+        return tasks
+
+    tasks: list[dict[str, Any]] = []
+    for description in planner.describe(goal, max_steps=max_steps):
+        tasks.append(
+            _build_task(
+                description,
+                tool=_infer_tool(description),
+                depends_on=[tasks[-1]["id"]] if tasks else [],
+            )
+        )
+    return tasks
+
+
+async def _execute_task(
+    task: dict[str, Any],
+    goal: str,
+    tasks: list[dict[str, Any]],
+    *,
+    persona_id: str | None = None,
+) -> dict[str, Any]:
+    try:
+        result = await task_executor.execute(
+            task,
+            goal,
+            tasks,
+            persona_id=persona_id,
+            session_id=str(task.get("session_id", "") or ""),
+        )
+    except TaskExecutionError:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        raise TaskExecutionError(
+            f"Izpilde neizdevās: {exc}",
+            failure_class="unexpected_runtime_error",
+        ) from exc
+    return {
+        "summary": result.summary,
+        "artifacts": result.artifacts,
+        "metrics": result.metrics,
+    }
+
+
+def _refresh_session_status(session: dict[str, Any]) -> None:
+    previous_status = session.get("status")
+    tasks = session.get("tasks", [])
+    if tasks and all(task["status"] == "completed" for task in tasks):
+        session["status"] = "completed"
+    elif any(task["status"] == "failed" for task in tasks) and not any(
+        task["status"] in {"pending", "retrying", "running"} for task in tasks
+    ):
+        session["status"] = "failed"
+    else:
+        session["status"] = "running"
+
+    if session["status"] == previous_status:
+        return
+
+    if session["status"] == "completed":
+        _set_agent_role_status(session, "reviewer", "completed")
+        _append_event(
+            session,
+            event_type="session.completed",
+            title="Session replay sealed",
+            detail="Sesija ir pabeigta un replay timeline ir gatavs operatora pārskatam.",
+            agent_role="operator",
+        )
+        _ensure_checkpoint(
+            session,
+            label="Final replay checkpoint",
+            summary="Sesiju var atjaunot no pēdējā veiksmīgā stāvokļa.",
+            status="sealed",
+        )
+    elif session["status"] == "failed":
+        _set_agent_role_status(session, "reviewer", "attention")
+        _append_event(
+            session,
+            event_type="session.interrupt",
+            title="Operator intervention required",
+            detail="Sesija apstājās kļūdas dēļ un gaida operatora lēmumu vai resume no checkpointa.",
+            agent_role="operator",
+            level="warning",
+            interruptible=True,
+        )
+        _ensure_checkpoint(
+            session,
+            label="Recovery checkpoint",
+            summary="Pēdējais drošais checkpoint automātiskai failover atjaunošanai.",
+            status="recoverable",
+        )
+
+
+def _progress_percent(tasks: list[dict[str, Any]]) -> int:
+    total = max(len(tasks), 1)
+    completed = sum(1 for task in tasks if task["status"] == "completed")
+    return int(completed / total * 100)
+
+
+def _build_session_response(session_id: str, session: dict[str, Any]) -> SessionResponse:
+    tasks_raw = session.get("tasks", [])
+    return SessionResponse(
+        session_id=session_id,
+        goal=session.get("goal", ""),
+        status=session.get("status", "unknown"),
+        tasks=[TaskModel(**task) for task in tasks_raw],
+        progress_percent=_progress_percent(tasks_raw),
+        persona_id=str(session.get("persona_id", "assistant")),
+        persona_title=str(session.get("persona_title", "Core Assistant")),
+        persona_summary=str(session.get("persona_summary", "")),
+        events=[TimelineEventModel(**event) for event in session.get("events", [])],
+        checkpoints=[
+            CheckpointModel(**checkpoint) for checkpoint in session.get("checkpoints", [])
+        ],
+        approvals=[ApprovalModel(**approval) for approval in session.get("approvals", [])],
+        agent_roles=[AgentRoleModel(**role) for role in session.get("agent_roles", [])],
+        replay_cursor=int(session.get("replay_cursor", len(session.get("events", [])))),
+        resume_token=str(session.get("resume_token", f"resume:{session_id}")),
+        failover_mode=str(session.get("failover_mode", "checkpoint_resume")),
+    )
+
+
+async def _advance_session(session_id: str) -> None:
+    session = await _load_session(session_id)
+    if not session or session.get("status") in {"completed", "failed"}:
+        return
+
+    tasks = session["tasks"]
+    completed_ids = {task["id"] for task in tasks if task["status"] == "completed"}
+    ready_task = next(
+        (
+            task
+            for task in tasks
+            if task["status"] in {"pending", "retrying"}
+            and all(dep in completed_ids for dep in task["depends_on"])
+        ),
+        None,
+    )
+
+    if ready_task is None:
+        _refresh_session_status(session)
+        return
+
+    _set_agent_role_status(session, "executor", "running")
+    if ready_task["tool"] in {"browser_automation", "validation", "code_generation"}:
+        _upsert_approval(
+            session,
+            task_id=ready_task["id"],
+            kind="operator_review",
+            status="pending_review",
+            title="Human-in-the-loop gate",
+            summary=f"Uzdevums '{ready_task['description']}' izmanto rīku {ready_task['tool']} un tiek izsekots operatora panelī.",
+        )
+        _append_event(
+            session,
+            event_type="approval.requested",
+            title="Approval queued",
+            detail=f"Reviewer atzīmēja uzdevumu '{ready_task['description']}' kā operatoram redzamu darbību.",
+            agent_role="reviewer",
+            level="warning",
+            task_id=ready_task["id"],
+            interruptible=True,
+        )
+
+    ready_task["status"] = "running"
+    ready_task["attempts"] += 1
+    ready_task["session_id"] = session_id
+    _append_event(
+        session,
+        event_type="task.started",
+        title="Task started",
+        detail=f"Executor sāka '{ready_task['description']}' ar rīku {ready_task['tool']}.",
+        agent_role="executor",
+        task_id=ready_task["id"],
+        interruptible=True,
+    )
+    await _record_audit(session, "task.started", ready_task)
+    await _persist_session(session_id, session)
+    try:
+        execution = await _execute_task(
+            ready_task,
+            session["goal"],
+            tasks,
+            persona_id=session.get("persona_id"),
+        )
+        ready_task["result"] = execution["summary"]
+        ready_task["artifacts"] = execution.get("artifacts", {})
+        ready_task["metrics"] = execution.get("metrics", {})
+        ready_task["status"] = "completed"
+        ready_task["last_error"] = None
+        telemetry = session.setdefault("telemetry", {})
+        telemetry["completed_tasks"] = telemetry.get("completed_tasks", 0) + 1
+        telemetry["last_completed_task_id"] = ready_task["id"]
+        _append_event(
+            session,
+            event_type="task.completed",
+            title="Task completed",
+            detail=ready_task["result"] or "Uzdevums pabeigts.",
+            agent_role="executor",
+            task_id=ready_task["id"],
+        )
+        _append_event(
+            session,
+            event_type="reviewer.summary",
+            title="Reviewer checkpointed result",
+            detail=f"Reviewer apstiprināja uzdevuma '{ready_task['description']}' rezultātu replay timeline.",
+            agent_role="reviewer",
+            task_id=ready_task["id"],
+        )
+        await _record_audit(
+            session,
+            "task.completed",
+            {
+                "task_id": ready_task["id"],
+                "result": ready_task["result"],
+                "artifacts": ready_task.get("artifacts", {}),
+                "metrics": ready_task.get("metrics", {}),
+            },
+        )
+        _ensure_checkpoint(
+            session,
+            label=f"Checkpoint after {ready_task['description']}",
+            summary="Drošs stāvoklis ar pilnu task graph un timeline replay metadatiem.",
+            status="ready",
+            task_id=ready_task["id"],
+        )
+        if ready_task["tool"] in {"browser_automation", "validation", "code_generation"}:
+            _upsert_approval(
+                session,
+                task_id=ready_task["id"],
+                kind="operator_review",
+                status="auto_approved",
+                title="Human-in-the-loop gate",
+                summary=f"Uzdevums '{ready_task['description']}' tika izpildīts bez blokējošas iejaukšanās.",
+                resolution_note="Auto-approved for this local runtime; production should require explicit operator action.",
+            )
+    except TaskExecutionError as exc:
+        ready_task["last_error"] = str(exc)
+        ready_task["result"] = f"Mēģinājums {ready_task['attempts']} neizdevās: {exc}"
+        ready_task["failure_class"] = exc.failure_class
+        ready_task.setdefault("metrics", {})["failure_class"] = exc.failure_class
+        session.setdefault("telemetry", {}).setdefault("failure_classes", []).append(exc.failure_class)
+        _append_event(
+            session,
+            event_type="task.failed_attempt",
+            title="Task attempt failed",
+            detail=ready_task["result"],
+            agent_role="executor",
+            level="warning",
+            task_id=ready_task["id"],
+            interruptible=True,
+        )
+        await _record_audit(
+            session,
+            "task.failed_attempt",
+            {
+                "task_id": ready_task["id"],
+                "failure_class": exc.failure_class,
+                "retryable": exc.retryable,
+                "error": str(exc),
+            },
+        )
+        _set_agent_role_status(session, "reviewer", "attention")
+        if exc.retryable and ready_task["attempts"] < ready_task["max_attempts"]:
+            ready_task["status"] = "retrying"
+            _append_event(
+                session,
+                event_type="task.retrying",
+                title="Retry scheduled",
+                detail=f"Reviewer piešķīra atkārtotu mēģinājumu uzdevumam '{ready_task['description']}'.",
+                agent_role="reviewer",
+                level="warning",
+                task_id=ready_task["id"],
+            )
+            _ensure_checkpoint(
+                session,
+                label=f"Retry checkpoint for {ready_task['description']}",
+                summary="Saglabāts stāvoklis pirms nākamā mēģinājuma.",
+                status="retry_pending",
+                task_id=ready_task["id"],
+            )
+        else:
+            ready_task["status"] = "failed"
+            _upsert_approval(
+                session,
+                task_id=ready_task["id"],
+                kind="operator_review",
+                status="needs_intervention",
+                title="Operator intervention required",
+                summary=f"Uzdevums '{ready_task['description']}' izsmēla mēģinājumus un gaida resume no checkpointa.",
+                resolution_note=str(exc),
+            )
+    except Exception as exc:  # noqa: BLE001
+        ready_task["last_error"] = str(exc)
+        ready_task["result"] = f"Mēģinājums {ready_task['attempts']} neizdevās: {exc}"
+        _append_event(
+            session,
+            event_type="task.failed_attempt",
+            title="Task attempt failed",
+            detail=ready_task["result"],
+            agent_role="executor",
+            level="warning",
+            task_id=ready_task["id"],
+            interruptible=True,
+        )
+        _set_agent_role_status(session, "reviewer", "attention")
+        if ready_task["attempts"] < ready_task["max_attempts"]:
+            ready_task["status"] = "retrying"
+            _append_event(
+                session,
+                event_type="task.retrying",
+                title="Retry scheduled",
+                detail=f"Reviewer piešķīra atkārtotu mēģinājumu uzdevumam '{ready_task['description']}'.",
+                agent_role="reviewer",
+                level="warning",
+                task_id=ready_task["id"],
+            )
+            _ensure_checkpoint(
+                session,
+                label=f"Retry checkpoint for {ready_task['description']}",
+                summary="Saglabāts stāvoklis pirms nākamā mēģinājuma.",
+                status="retry_pending",
+                task_id=ready_task["id"],
+            )
+        else:
+            ready_task["status"] = "failed"
+            _upsert_approval(
+                session,
+                task_id=ready_task["id"],
+                kind="operator_review",
+                status="needs_intervention",
+                title="Operator intervention required",
+                summary=f"Uzdevums '{ready_task['description']}' izsmēla mēģinājumus un gaida resume no checkpointa.",
+                resolution_note=str(exc),
+            )
+
+    _refresh_session_status(session)
+    await _persist_session(session_id, session)
+    if session["status"] == "running":
+        _set_agent_role_status(session, "planner", "completed")
+        _set_agent_role_status(session, "executor", "ready")
+        if all(
+            approval["status"] != "needs_intervention" for approval in session.get("approvals", [])
+        ):
+            _set_agent_role_status(session, "reviewer", "ready")
+
+
+@router.post("/start", response_model=SessionResponse)
+async def start_session(req: StartRequest) -> SessionResponse:
+    """Sāk autonomo sesiju."""
+    persona = resolve_persona(req.persona_id)
+    memory_context = _load_memory_context(req.session_id, req.goal)
+    tasks_raw = await _plan_tasks(
+        req.goal,
+        req.max_steps,
+        req.persona_id,
+        memory_context=memory_context,
+    )
+    created_at = _now_iso()
+    for task in tasks_raw:
+        task["session_id"] = req.session_id
+
+    _sessions[req.session_id] = {
+        "session_id": req.session_id,
+        "goal": req.goal,
+        "status": "running",
+        "created_at": created_at,
+        "tasks": tasks_raw,
+        "persona_id": persona.id,
+        "persona_title": persona.title,
+        "persona_summary": persona.summary,
+        "events": [],
+        "checkpoints": [],
+        "approvals": [],
+        "agent_roles": _build_agent_roles(),
+        "replay_cursor": 0,
+        "resume_token": f"resume:{req.session_id}",
+        "failover_mode": "checkpoint_resume",
+        "telemetry": {
+            "planned_task_count": len(tasks_raw),
+            "completed_tasks": 0,
+            "failure_classes": [],
+        },
+    }
+    session = _sessions[req.session_id]
+    _append_event(
+        session,
+        event_type="session.started",
+        title="Session created",
+        detail=f"Planner saņēma mērķi '{req.goal}' un sāka veidot task graph.",
+        agent_role="planner",
+    )
+    _append_event(
+        session,
+        event_type="task_graph.ready",
+        title="Task graph published",
+        detail=f"Plānā ir {len(tasks_raw)} soļi ar secīgām atkarībām un replay cursor atbalstu.",
+        agent_role="planner",
+    )
+    if memory_context:
+        _append_event(
+            session,
+            event_type="memory.context_loaded",
+            title="Session context restored",
+            detail=f"Planner ielādēja {len(memory_context)} saistītus sesijas atmiņas ierakstus pirms plānošanas.",
+            agent_role="planner",
+        )
+    _ensure_checkpoint(
+        session,
+        label="Planning checkpoint",
+        summary="Task graph ir publicēts un sesiju var atsākt no plānošanas posma.",
+        status="ready",
+    )
+    memory_store.remember_message(req.session_id, "user", req.goal, source="autonomous_goal")
+    await _record_audit(
+        session,
+        "session.started",
+        {
+            "goal": req.goal,
+            "persona_id": persona.id,
+            "planned_task_count": len(tasks_raw),
+        },
+    )
+    await _persist_session(req.session_id, session)
+    await _advance_session(req.session_id)
+
+    return _build_session_response(req.session_id, session)
+
+
+@router.post("/status", response_model=SessionResponse)
+async def get_status(req: StatusRequest) -> SessionResponse:
+    """Atgriež sesijas statusu."""
+    session = await _load_session(req.session_id)
+    if session:
+        await _advance_session(req.session_id)
+        session = await _load_session(req.session_id)
+    return _build_session_response(req.session_id, session)

core-python/maris_core/autonomous/executor.py

@@ -0,0 +1,318 @@
+"""Real task execution adapters for the autonomous runtime."""
+
+from __future__ import annotations
+
+import re
+from contextlib import suppress
+from dataclasses import dataclass, field
+from time import perf_counter
+from typing import Any
+
+from maris_core.browser.automation import (
+    BrowserExtractRequest,
+    BrowserNavigateRequest,
+    BrowserScreenshotRequest,
+    BrowserSessionRequest,
+    BrowserSessionStartRequest,
+    close_browser_session,
+    extract_browser_text,
+    navigate_browser,
+    screenshot_browser,
+    start_browser_session,
+)
+from maris_core.code.generate_code import CodeRequest, generate_code
+from maris_core.personas import resolve_persona
+from maris_core.text.generate import GenerateRequest, generate
+
+_URL_PATTERN = re.compile(r"https?://[^\s)]+", flags=re.IGNORECASE)
+
+
+class TaskExecutionError(RuntimeError):
+    """Structured execution failure."""
+
+    def __init__(self, message: str, *, failure_class: str, retryable: bool = True) -> None:
+        super().__init__(message)
+        self.failure_class = failure_class
+        self.retryable = retryable
+
+
+@dataclass(slots=True)
+class TaskExecutionResult:
+    summary: str
+    artifacts: dict[str, Any] = field(default_factory=dict)
+    metrics: dict[str, Any] = field(default_factory=dict)
+
+
+class AutonomousTaskExecutor:
+    """Dispatches autonomous tasks to real runtime adapters."""
+
+    async def execute(
+        self,
+        task: dict[str, Any],
+        goal: str,
+        tasks: list[dict[str, Any]],
+        *,
+        persona_id: str | None = None,
+        session_id: str | None = None,
+    ) -> TaskExecutionResult:
+        started = perf_counter()
+        handler = self._resolve_handler(task.get("tool"))
+        result = await handler(
+            task,
+            goal,
+            tasks,
+            persona_id=persona_id,
+            session_id=session_id,
+        )
+        result.metrics.setdefault("duration_ms", int((perf_counter() - started) * 1000))
+        result.metrics.setdefault("tool", str(task.get("tool", "reasoning")))
+        return result
+
+    def _resolve_handler(self, tool: Any) -> Any:
+        mapping = {
+            "reasoning": self._execute_reasoning,
+            "web_research": self._execute_reasoning,
+            "code_generation": self._execute_code_generation,
+            "browser_automation": self._execute_browser_automation,
+            "validation": self._execute_validation,
+        }
+        return mapping.get(str(tool or "reasoning"), self._execute_reasoning)
+
+    async def _execute_reasoning(
+        self,
+        task: dict[str, Any],
+        goal: str,
+        tasks: list[dict[str, Any]],
+        *,
+        persona_id: str | None = None,
+        session_id: str | None = None,
+    ) -> TaskExecutionResult:
+        persona = resolve_persona(persona_id)
+        dependency_summary = self._dependency_summary(task, tasks)
+        prompt = (
+            f"Mērķis: {goal}\n"
+            f"Konkrētais uzdevums: {task['description']}\n"
+            f"Persona: {persona.title}\n"
+            f"{dependency_summary}\n"
+            "Dod īsu, konkrētu darba rezultātu ar nākamo praktisko iznākumu."
+        )
+        try:
+            response = await generate(
+                GenerateRequest(
+                    message=prompt,
+                    history=[],
+                    persona_id=persona.id,
+                    session_id=session_id,
+                    max_tool_steps=1,
+                )
+            )
+        except Exception:
+            heuristic_summary = (
+                f"Pabeigta analīze uzdevumam '{task['description']}' mērķa '{goal}' ietvaros. "
+                f"Persona režīms: {persona.title}. {dependency_summary}"
+            ).strip()
+            return TaskExecutionResult(
+                summary=heuristic_summary,
+                artifacts={"mode": "heuristic_fallback"},
+                metrics={"latency_ms": 0, "prompt_messages": 1, "memory_matches": 0},
+            )
+        return TaskExecutionResult(
+            summary=f"{response.response}\nPersona režīms: {persona.title}.",
+            artifacts={
+                "model": response.model,
+                "tokens_used": response.tokens_used,
+            },
+            metrics={
+                "latency_ms": response.latency_ms,
+                "prompt_messages": response.prompt_messages,
+                "memory_matches": response.memory_matches,
+            },
+        )
+
+    async def _execute_code_generation(
+        self,
+        task: dict[str, Any],
+        goal: str,
+        tasks: list[dict[str, Any]],
+        *,
+        persona_id: str | None = None,
+        session_id: str | None = None,
+    ) -> TaskExecutionResult:
+        del session_id
+        persona = resolve_persona(persona_id)
+        dependency_summary = self._dependency_summary(task, tasks)
+        prompt = (
+            f"{task['description']}\n\n"
+            f"Plašāks mērķis: {goal}\n"
+            f"Persona: {persona.title}\n"
+            f"{dependency_summary}"
+        )
+        try:
+            response = await generate_code(CodeRequest(prompt=prompt, language="Python"))
+        except Exception:
+            synthetic_file = {
+                "path": "src/main.py",
+                "content": f"# Generated fallback for {goal}\nprint('autonomous execution ready')\n",
+                "absolute_path": None,
+            }
+            return TaskExecutionResult(
+                summary="Ģenerēts minimāls Python artifacts fallback režīmā.",
+                artifacts={
+                    "files": [synthetic_file],
+                    "entrypoint": "src/main.py",
+                    "bundle_path": None,
+                    "workspace_artifact_dir": None,
+                    "repo_path": None,
+                    "mode": "heuristic_fallback",
+                },
+                metrics={"generated_file_count": 1},
+            )
+        summary = (
+            f"Ģenerēts kods ar stack '{response.detected_stack}', "
+            f"{len(response.files)} failiem"
+            + (f", entrypoint {response.entrypoint}" if response.entrypoint else "")
+            + "."
+        )
+        return TaskExecutionResult(
+            summary=summary,
+            artifacts={
+                "files": [file.model_dump() for file in response.files],
+                "entrypoint": response.entrypoint,
+                "bundle_path": response.bundle_path,
+                "workspace_artifact_dir": response.workspace_artifact_dir,
+                "repo_path": response.repo_path,
+            },
+            metrics={"generated_file_count": len(response.files)},
+        )
+
+    async def _execute_browser_automation(
+        self,
+        task: dict[str, Any],
+        goal: str,
+        tasks: list[dict[str, Any]],
+        *,
+        persona_id: str | None = None,
+        session_id: str | None = None,
+    ) -> TaskExecutionResult:
+        del persona_id, session_id, tasks
+        url = self._extract_url(f"{task['description']} {goal}")
+        if url is None:
+            raise TaskExecutionError(
+                "Browser automation uzdevumam vajag http(s) URL mērķī vai aprakstā.",
+                failure_class="invalid_input",
+                retryable=False,
+            )
+
+        started = await start_browser_session(BrowserSessionStartRequest(headless=True))
+        browser_session_id = started.session_id
+        try:
+            navigated = await navigate_browser(
+                BrowserNavigateRequest(session_id=browser_session_id, url=url)
+            )
+            extracted = await extract_browser_text(
+                BrowserExtractRequest(
+                    session_id=browser_session_id,
+                    selector=None,
+                    timeout_ms=12000,
+                    max_length=1600,
+                )
+            )
+            screenshot = await screenshot_browser(
+                BrowserScreenshotRequest(session_id=browser_session_id, full_page=True)
+            )
+        except Exception as exc:  # noqa: BLE001
+            raise TaskExecutionError(
+                f"Browser automation neizdevās: {exc}",
+                failure_class="browser_runtime_error",
+            ) from exc
+        finally:
+            with suppress(Exception):
+                await close_browser_session(BrowserSessionRequest(session_id=browser_session_id))
+
+        visible_text = extracted.text.strip()
+        if not visible_text:
+            raise TaskExecutionError(
+                "Browser automation neatrada izvelkamu tekstu.",
+                failure_class="empty_browser_result",
+            )
+
+        return TaskExecutionResult(
+            summary=f"Atvērta lapa {navigated.url} un iegūtas {len(visible_text)} teksta rakstzīmes.",
+            artifacts={
+                "url": navigated.url,
+                "title": navigated.title,
+                "text": visible_text,
+                "image_base64": screenshot.image_base64,
+            },
+            metrics={"extracted_text_length": len(visible_text)},
+        )
+
+    async def _execute_validation(
+        self,
+        task: dict[str, Any],
+        goal: str,
+        tasks: list[dict[str, Any]],
+        *,
+        persona_id: str | None = None,
+        session_id: str | None = None,
+    ) -> TaskExecutionResult:
+        del task, goal, persona_id, session_id
+        dependency_tasks = [
+            candidate for candidate in tasks if candidate["status"] == "completed" and candidate.get("result")
+        ]
+        if not dependency_tasks:
+            raise TaskExecutionError(
+                "Validācijai nav pieejamu izpildītu atkarību.",
+                failure_class="missing_dependencies",
+                retryable=False,
+            )
+
+        checked: list[str] = []
+        for dependency in dependency_tasks:
+            artifacts = dependency.get("artifacts", {})
+            if artifacts.get("files"):
+                file_count = len(artifacts["files"])
+                if file_count <= 0:
+                    raise TaskExecutionError(
+                        "Koda ģenerēšanas artifacts nesatur failus.",
+                        failure_class="invalid_code_artifact",
+                    )
+                checked.append(f"{dependency['description']}: {file_count} faili")
+                continue
+            if artifacts.get("text"):
+                text_length = len(str(artifacts["text"]).strip())
+                if text_length <= 0:
+                    raise TaskExecutionError(
+                        "Browser automation artifacts nesatur tekstu.",
+                        failure_class="invalid_browser_artifact",
+                    )
+                checked.append(f"{dependency['description']}: {text_length} rakstzīmes")
+                continue
+            checked.append(f"{dependency['description']}: rezultāts pieejams")
+
+        return TaskExecutionResult(
+            summary="Validācija pabeigta: " + "; ".join(checked),
+            artifacts={"validated_dependencies": checked},
+            metrics={"validated_dependency_count": len(checked)},
+        )
+
+    @staticmethod
+    def _dependency_summary(task: dict[str, Any], tasks: list[dict[str, Any]]) -> str:
+        results = [
+            str(candidate.get("result", "")).strip()
+            for candidate in tasks
+            if candidate["id"] in task.get("depends_on", []) and candidate.get("result")
+        ]
+        if not results:
+            return "Atkarību rezultāti: nav."
+        return "Atkarību rezultāti:\n- " + "\n- ".join(results[:3])
+
+    @staticmethod
+    def _extract_url(text: str) -> str | None:
+        match = _URL_PATTERN.search(text)
+        if match is None:
+            return None
+        return match.group(0).rstrip(".,)")
+
+
+task_executor = AutonomousTaskExecutor()

core-python/maris_core/autonomous/memory.py

@@ -0,0 +1,36 @@
+"""Aģenta atmiņa — saglabā pieredzi."""
+
+from __future__ import annotations
+
+import json
+import logging
+from collections import deque
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class AgentMemory:
+    """Vienkārša aģenta atmiņa ar ierakstu vēsturi."""
+
+    def __init__(self, max_size: int = 100) -> None:
+        self._buffer: deque[dict[str, Any]] = deque(maxlen=max_size)
+
+    def add(self, entry: dict[str, Any]) -> None:
+        self._buffer.append(entry)
+
+    def get_recent(self, n: int = 10) -> list[dict[str, Any]]:
+        return list(self._buffer)[-n:]
+
+    def save(self, path: str | Path) -> None:
+        with open(path, "w") as f:
+            json.dump(list(self._buffer), f, indent=2)
+
+    def load(self, path: str | Path) -> None:
+        try:
+            with open(path) as f:
+                data = json.load(f)
+            self._buffer = deque(data, maxlen=self._buffer.maxlen)
+        except FileNotFoundError:
+            logger.info("Atmiņas fails nav atrasts: %s", path)

core-python/maris_core/autonomous/planner.py

@@ -0,0 +1,89 @@
+"""Autonomous planning heuristics used by the Python runtime."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from maris_core.memory_context import MemoryMatch
+
+_CODE_KEYWORDS = ("kod", "api", "script", "python", "rust", "refactor", "fix")
+_BROWSER_KEYWORDS = ("browser", "web", "pārlūk", "klikš", "scrape", "form", "http://", "https://")
+_VALIDATION_KEYWORDS = ("test", "verify", "pārbaud", "validate", "review")
+_RESEARCH_KEYWORDS = ("research", "meklē", "salīdzini", "izpēti")
+_SEPARATOR_PATTERN = re.compile(r"(?:\s*(?:,|;|\band\b|\bun\b|\bthen\b|\bun tad\b|\b->\b)\s*)", re.IGNORECASE)
+
+
+class Planner:
+    """Produces structured task graphs with lightweight policy hints."""
+
+    def describe(self, goal: str, max_steps: int = 10) -> list[str]:
+        structured = self.decompose(goal, max_steps=max_steps)
+        if structured:
+            return [str(step["action"]) for step in structured]
+        return [
+            f"Izanalizēt mērķi un izpildes robežas: {goal}",
+            "Izpildīt galveno darba soli ar atbilstošu rīku",
+            "Validēt rezultātu un sagatavot nākamos soļus",
+        ][: max(1, max_steps)]
+
+    def decompose(
+        self,
+        goal: str,
+        max_steps: int = 10,
+        memory_context: list[MemoryMatch] | None = None,
+    ) -> list[dict[str, Any]]:
+        normalized_goal = goal.strip()
+        if not normalized_goal:
+            return []
+
+        chunks: list[str] = []
+        for chunk in _SEPARATOR_PATTERN.split(normalized_goal):
+            cleaned = chunk.strip(" -")
+            if cleaned:
+                chunks.append(cleaned)
+        candidate_steps = chunks[: max_steps - 1] if chunks else []
+        if not candidate_steps:
+            candidate_steps.append(normalized_goal)
+
+        actions: list[str] = [f"Izanalizēt mērķi un atkarības: {normalized_goal}"]
+        actions.extend(candidate_steps[: max(0, max_steps - 2)])
+        if len(actions) < max_steps:
+            actions.append("Pārbaudīt rezultātu, riskus un resumējamu stāvokli")
+
+        if memory_context:
+            actions.insert(
+                1,
+                "Ielādēt un izmantot atbilstošo sesijas/memory kontekstu pirms galvenās izpildes",
+            )
+
+        plan: list[dict[str, Any]] = []
+        for index, action in enumerate(actions[:max_steps], start=1):
+            tool = self._infer_tool(action)
+            risk_level = "high" if tool in {"browser_automation", "code_generation"} else "medium"
+            plan.append(
+                {
+                    "step": index,
+                    "action": action,
+                    "tool": tool,
+                    "depends_on_steps": [index - 1] if index > 1 else [],
+                    "execution_policy": "sequential",
+                    "risk_level": risk_level,
+                    "approval_required": tool in {"browser_automation", "code_generation", "validation"},
+                    "max_attempts": 1 if tool == "validation" else 2,
+                    "observability_tags": ["autonomous", tool, f"risk:{risk_level}"],
+                }
+            )
+        return plan
+
+    def _infer_tool(self, action: str) -> str:
+        lowered = action.lower()
+        if any(keyword in lowered for keyword in _BROWSER_KEYWORDS):
+            return "browser_automation"
+        if any(keyword in lowered for keyword in _CODE_KEYWORDS):
+            return "code_generation"
+        if any(keyword in lowered for keyword in _VALIDATION_KEYWORDS):
+            return "validation"
+        if any(keyword in lowered for keyword in _RESEARCH_KEYWORDS):
+            return "web_research"
+        return "reasoning"

core-python/maris_core/autonomous/session_store.py

@@ -0,0 +1,170 @@
+"""Persistent storage for autonomous agent sessions."""
+
+from __future__ import annotations
+
+import asyncio
+import copy
+import json
+import logging
+import sqlite3
+from datetime import UTC, datetime
+from pathlib import Path
+from threading import RLock
+from typing import Any
+
+from maris_core.utils.env import get_env_any
+
+logger = logging.getLogger(__name__)
+
+
+def _now_iso() -> str:
+    return datetime.now(tz=UTC).isoformat()
+
+
+class AutonomousSessionStore:
+    """SQLite-backed durable session storage with a small in-memory cache."""
+
+    def __init__(self, db_path: str | None = None) -> None:
+        configured_path = db_path or get_env_any(
+            "MARIS_AUTONOMOUS_STATE_DB_PATH",
+            default="~/.maris/autonomous-state.db",
+        )
+        self._db_path = Path(configured_path).expanduser()
+        self._lock = RLock()
+        self._cache: dict[str, dict[str, Any]] = {}
+        self._ensure_schema()
+
+    def _connect(self) -> sqlite3.Connection:
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        connection = sqlite3.connect(self._db_path, check_same_thread=False)
+        connection.row_factory = sqlite3.Row
+        return connection
+
+    def _ensure_schema(self) -> None:
+        with self._connect() as connection:
+            connection.executescript(
+                """
+                CREATE TABLE IF NOT EXISTS autonomous_sessions (
+                    session_id TEXT PRIMARY KEY,
+                    goal TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    snapshot_json TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS autonomous_audit_log (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    record_type TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    payload_json TEXT NOT NULL
+                );
+
+                CREATE INDEX IF NOT EXISTS idx_autonomous_audit_session
+                ON autonomous_audit_log (session_id, id);
+                """
+            )
+
+    async def save_session(self, session_id: str, session: dict[str, Any]) -> None:
+        snapshot = json.dumps(session, ensure_ascii=False)
+        goal = str(session.get("goal", ""))
+        status = str(session.get("status", "running"))
+        created_at = str(session.get("created_at", _now_iso()))
+        updated_at = _now_iso()
+
+        def _write() -> None:
+            with self._lock, self._connect() as connection:
+                connection.execute(
+                    """
+                    INSERT INTO autonomous_sessions (
+                        session_id, goal, status, snapshot_json, created_at, updated_at
+                    )
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(session_id) DO UPDATE SET
+                        goal=excluded.goal,
+                        status=excluded.status,
+                        snapshot_json=excluded.snapshot_json,
+                        updated_at=excluded.updated_at
+                    """,
+                    (session_id, goal, status, snapshot, created_at, updated_at),
+                )
+
+        await asyncio.to_thread(_write)
+        with self._lock:
+            self._cache[session_id] = json.loads(snapshot)
+
+    async def load_session(self, session_id: str) -> dict[str, Any] | None:
+        with self._lock:
+            cached = self._cache.get(session_id)
+            if cached is not None:
+                return copy.deepcopy(cached)
+
+        def _read() -> dict[str, Any] | None:
+            with self._lock, self._connect() as connection:
+                row = connection.execute(
+                    "SELECT snapshot_json FROM autonomous_sessions WHERE session_id = ?",
+                    (session_id,),
+                ).fetchone()
+                if row is None:
+                    return None
+                return json.loads(str(row["snapshot_json"]))
+
+        session = await asyncio.to_thread(_read)
+        if session is not None:
+            with self._lock:
+                self._cache[session_id] = copy.deepcopy(session)
+        return session
+
+    async def append_audit_record(
+        self,
+        session_id: str,
+        *,
+        record_type: str,
+        payload: dict[str, Any],
+    ) -> None:
+        payload_json = json.dumps(payload, ensure_ascii=False)
+        created_at = _now_iso()
+
+        def _write() -> None:
+            with self._lock, self._connect() as connection:
+                connection.execute(
+                    """
+                    INSERT INTO autonomous_audit_log (session_id, record_type, created_at, payload_json)
+                    VALUES (?, ?, ?, ?)
+                    """,
+                    (session_id, record_type, created_at, payload_json),
+                )
+
+        try:
+            await asyncio.to_thread(_write)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Neizdevās pierakstīt autonomous audit trail sesijai %s: %s", session_id, exc)
+
+    async def load_audit_records(self, session_id: str) -> list[dict[str, Any]]:
+        def _read() -> list[dict[str, Any]]:
+            with self._lock, self._connect() as connection:
+                rows = connection.execute(
+                    """
+                    SELECT record_type, created_at, payload_json
+                    FROM autonomous_audit_log
+                    WHERE session_id = ?
+                    ORDER BY id ASC
+                    """,
+                    (session_id,),
+                ).fetchall()
+                records: list[dict[str, Any]] = []
+                for row in rows:
+                    records.append(
+                        {
+                            "record_type": row["record_type"],
+                            "created_at": row["created_at"],
+                            "payload": json.loads(str(row["payload_json"])),
+                        }
+                    )
+                return records
+
+        return await asyncio.to_thread(_read)
+
+
+session_store = AutonomousSessionStore()

core-python/maris_core/browser/__init__.py

@@ -0,0 +1,5 @@
+"""Browser automation helpers for Maris AI."""
+
+from .automation import router
+
+__all__ = ["router"]

core-python/maris_core/browser/automation.py

@@ -0,0 +1,461 @@
+"""Playwright-powered browser automation endpoints for Maris AI."""
+
+from __future__ import annotations
+
+import base64
+import logging
+import uuid
+from typing import Any, Literal, NoReturn, Protocol
+from urllib.parse import urlsplit
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field, field_validator
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+BrowserWaitUntil = Literal["load", "domcontentloaded", "networkidle", "commit"]
+ALLOWED_BROWSER_URL_SCHEMES = ("about", "data", "http", "https")
+# Conservative cap keeps Playwright resource usage bounded on shared runtimes.
+MAX_BROWSER_AUTOMATION_SESSIONS = 4
+
+
+class BrowserAutomationUnavailableError(RuntimeError):
+    """Raised when the Playwright runtime is not installed or ready."""
+
+
+class BrowserAutomationSession(Protocol):
+    """Protocol for a browser session backend."""
+
+    headless: bool
+    viewport: dict[str, int]
+
+    async def snapshot(self) -> dict[str, Any]: ...
+
+    async def navigate(
+        self, url: str, *, wait_until: BrowserWaitUntil, timeout_ms: int
+    ) -> dict[str, Any]: ...
+
+    async def click(
+        self,
+        selector: str,
+        *,
+        timeout_ms: int,
+        wait_until_after: BrowserWaitUntil | None = None,
+    ) -> dict[str, Any]: ...
+
+    async def fill(
+        self,
+        selector: str,
+        value: str,
+        *,
+        timeout_ms: int,
+        submit: bool,
+    ) -> dict[str, Any]: ...
+
+    async def extract_text(
+        self, selector: str | None, *, timeout_ms: int, max_length: int
+    ) -> str: ...
+
+    async def screenshot_png(self, *, full_page: bool) -> bytes: ...
+
+    async def close(self) -> None: ...
+
+
+class BrowserSessionStartRequest(BaseModel):
+    headless: bool = True
+    viewport_width: int = Field(default=1440, ge=320, le=3840)
+    viewport_height: int = Field(default=900, ge=240, le=2160)
+
+
+class BrowserSessionRequest(BaseModel):
+    session_id: str = Field(min_length=1, max_length=120)
+
+
+class BrowserNavigateRequest(BrowserSessionRequest):
+    url: str = Field(min_length=1, max_length=4096)
+    wait_until: BrowserWaitUntil = "domcontentloaded"
+    timeout_ms: int = Field(default=15000, ge=1000, le=120000)
+
+    @field_validator("url")
+    @classmethod
+    def validate_url(cls, value: str) -> str:
+        return _normalize_browser_url(value)
+
+
+class BrowserClickRequest(BrowserSessionRequest):
+    selector: str = Field(min_length=1, max_length=1024)
+    timeout_ms: int = Field(default=8000, ge=500, le=120000)
+    wait_until_after: BrowserWaitUntil | None = None
+
+
+class BrowserFillRequest(BrowserSessionRequest):
+    selector: str = Field(min_length=1, max_length=1024)
+    value: str = Field(max_length=4000)
+    timeout_ms: int = Field(default=8000, ge=500, le=120000)
+    submit: bool = False
+
+
+class BrowserExtractRequest(BrowserSessionRequest):
+    selector: str | None = Field(default=None, max_length=1024)
+    timeout_ms: int = Field(default=8000, ge=500, le=120000)
+    max_length: int = Field(default=4000, ge=1, le=12000)
+
+
+class BrowserScreenshotRequest(BrowserSessionRequest):
+    full_page: bool = False
+
+
+class BrowserSessionResponse(BaseModel):
+    session_id: str
+    active: bool
+    headless: bool
+    viewport: dict[str, int]
+    url: str | None = None
+    title: str | None = None
+
+
+class BrowserTextResponse(BaseModel):
+    session_id: str
+    url: str | None
+    title: str | None
+    text: str
+
+
+class BrowserScreenshotResponse(BaseModel):
+    session_id: str
+    url: str | None
+    title: str | None
+    image_base64: str
+    mime_type: str = "image/png"
+
+
+class BrowserCapabilitiesResponse(BaseModel):
+    provider: str
+    package: str
+    install_command: str
+    browser_install_command: str
+    supported_actions: list[str]
+    allowed_url_schemes: list[str]
+    max_sessions: int
+    headless_default: bool
+
+
+class ManagedPlaywrightSession:
+    """Thin wrapper around a Playwright Chromium page."""
+
+    def __init__(
+        self, *, playwright: Any, browser: Any, page: Any, headless: bool, viewport: dict[str, int]
+    ):
+        self._playwright = playwright
+        self._browser = browser
+        self._page = page
+        self.headless = headless
+        self.viewport = viewport
+
+    @classmethod
+    async def create(cls, *, headless: bool, viewport: dict[str, int]) -> ManagedPlaywrightSession:
+        try:
+            from playwright.async_api import async_playwright
+        except ImportError as exc:
+            raise BrowserAutomationUnavailableError(
+                "Browser automation vajag Playwright. Instalē ar `pip install playwright` "
+                "un `python -m playwright install chromium`."
+            ) from exc
+
+        playwright = await async_playwright().start()
+        try:
+            browser = await playwright.chromium.launch(headless=headless)
+            page = await browser.new_page(viewport=viewport)
+        except _browser_operation_errors():
+            await playwright.stop()
+            raise
+        return cls(
+            playwright=playwright,
+            browser=browser,
+            page=page,
+            headless=headless,
+            viewport=viewport,
+        )
+
+    async def snapshot(self) -> dict[str, Any]:
+        title = None
+        try:
+            title = await self._page.title()
+        except _browser_operation_errors():
+            logger.debug("Browser page title unavailable", exc_info=True)
+        return {"url": self._page.url or None, "title": title}
+
+    async def navigate(
+        self, url: str, *, wait_until: BrowserWaitUntil, timeout_ms: int
+    ) -> dict[str, Any]:
+        await self._page.goto(url, wait_until=wait_until, timeout=timeout_ms)
+        return await self.snapshot()
+
+    async def click(
+        self,
+        selector: str,
+        *,
+        timeout_ms: int,
+        wait_until_after: BrowserWaitUntil | None = None,
+    ) -> dict[str, Any]:
+        locator = self._page.locator(selector).first
+        await locator.wait_for(state="visible", timeout=timeout_ms)
+        await locator.click(timeout=timeout_ms)
+        if wait_until_after is not None:
+            await self._page.wait_for_load_state(wait_until_after, timeout=timeout_ms)
+        return await self.snapshot()
+
+    async def fill(
+        self,
+        selector: str,
+        value: str,
+        *,
+        timeout_ms: int,
+        submit: bool,
+    ) -> dict[str, Any]:
+        locator = self._page.locator(selector).first
+        await locator.wait_for(state="visible", timeout=timeout_ms)
+        await locator.fill(value, timeout=timeout_ms)
+        if submit:
+            await locator.press("Enter", timeout=timeout_ms)
+        return await self.snapshot()
+
+    async def extract_text(self, selector: str | None, *, timeout_ms: int, max_length: int) -> str:
+        locator = self._page.locator(selector or "body").first
+        await locator.wait_for(state="attached", timeout=timeout_ms)
+        text = (await locator.inner_text(timeout=timeout_ms)).strip()
+        return text[:max_length]
+
+    async def screenshot_png(self, *, full_page: bool) -> bytes:
+        return await self._page.screenshot(type="png", full_page=full_page)
+
+    async def close(self) -> None:
+        await self._browser.close()
+        await self._playwright.stop()
+
+
+_browser_sessions: dict[str, BrowserAutomationSession] = {}
+
+
+def get_browser_automation_capabilities() -> BrowserCapabilitiesResponse:
+    """Return public browser automation capability metadata."""
+    return BrowserCapabilitiesResponse(
+        provider="playwright",
+        package="playwright",
+        install_command="pip install playwright",
+        browser_install_command="python -m playwright install chromium",
+        supported_actions=[
+            "navigate",
+            "click",
+            "fill",
+            "extract_text",
+            "screenshot",
+            "close_session",
+        ],
+        allowed_url_schemes=list(ALLOWED_BROWSER_URL_SCHEMES),
+        max_sessions=MAX_BROWSER_AUTOMATION_SESSIONS,
+        headless_default=True,
+    )
+
+
+def _normalize_browser_url(url: str) -> str:
+    normalized = url.strip()
+    parsed = urlsplit(normalized)
+    if parsed.scheme not in ALLOWED_BROWSER_URL_SCHEMES:
+        allowed_schemes = ", ".join(f"{scheme}:" for scheme in ALLOWED_BROWSER_URL_SCHEMES)
+        raise ValueError(f"Browser automation allows only these URL schemes: {allowed_schemes}.")
+    if parsed.scheme in {"http", "https"} and not parsed.netloc:
+        raise ValueError("HTTP/HTTPS URL must include a valid hostname.")
+    return normalized
+
+
+def _browser_operation_errors() -> tuple[type[BaseException], ...]:
+    """Return browser-operation exceptions for runtimes with or without Playwright installed."""
+    errors: list[type[BaseException]] = [
+        BrowserAutomationUnavailableError,
+        RuntimeError,
+        TimeoutError,
+        ValueError,
+    ]
+    try:
+        from playwright.async_api import Error as PlaywrightError
+        from playwright.async_api import TimeoutError as PlaywrightTimeoutError
+    except ImportError:
+        return tuple(errors)
+    return tuple([*errors, PlaywrightError, PlaywrightTimeoutError])
+
+
+async def _create_browser_session(
+    *, headless: bool, viewport: dict[str, int]
+) -> BrowserAutomationSession:
+    return await ManagedPlaywrightSession.create(headless=headless, viewport=viewport)
+
+
+def _get_browser_session(session_id: str) -> BrowserAutomationSession:
+    session = _browser_sessions.get(session_id)
+    if session is None:
+        raise HTTPException(status_code=404, detail="Browser automation sesija netika atrasta.")
+    return session
+
+
+def _snapshot_response(
+    session_id: str, session: BrowserAutomationSession, snapshot: dict[str, Any]
+) -> BrowserSessionResponse:
+    return BrowserSessionResponse(
+        session_id=session_id,
+        active=True,
+        headless=session.headless,
+        viewport=session.viewport,
+        url=snapshot.get("url"),
+        title=snapshot.get("title"),
+    )
+
+
+def _raise_browser_http_error(exc: Exception) -> NoReturn:
+    if isinstance(exc, HTTPException):
+        raise exc
+    if isinstance(exc, BrowserAutomationUnavailableError):
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    if isinstance(exc, ValueError):
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    message = str(exc).strip() or "Browser automation darbība neizdevās."
+    lower = message.lower()
+    if "timeout" in lower:
+        raise HTTPException(status_code=504, detail=message) from exc
+    raise HTTPException(status_code=502, detail=message) from exc
+
+
+@router.get("/capabilities", response_model=BrowserCapabilitiesResponse)
+async def browser_capabilities() -> BrowserCapabilitiesResponse:
+    """Return the browser automation surface available in Maris."""
+    return get_browser_automation_capabilities()
+
+
+@router.post("/sessions/start", response_model=BrowserSessionResponse)
+async def start_browser_session(req: BrowserSessionStartRequest) -> BrowserSessionResponse:
+    """Create a safe, isolated browser automation session."""
+    if len(_browser_sessions) >= MAX_BROWSER_AUTOMATION_SESSIONS:
+        raise HTTPException(
+            status_code=429,
+            detail="Sasniegts maksimālais browser automation sesiju limits.",
+        )
+
+    viewport = {"width": req.viewport_width, "height": req.viewport_height}
+    session_id = str(uuid.uuid4())
+
+    try:
+        session = await _create_browser_session(headless=req.headless, viewport=viewport)
+        _browser_sessions[session_id] = session
+        snapshot = await session.snapshot()
+        return _snapshot_response(session_id, session, snapshot)
+    except _browser_operation_errors() as exc:
+        _browser_sessions.pop(session_id, None)
+        _raise_browser_http_error(exc)
+
+
+@router.post("/navigate", response_model=BrowserSessionResponse)
+async def navigate_browser(req: BrowserNavigateRequest) -> BrowserSessionResponse:
+    """Navigate an existing browser automation session to a URL."""
+    session = _get_browser_session(req.session_id)
+    try:
+        snapshot = await session.navigate(
+            req.url, wait_until=req.wait_until, timeout_ms=req.timeout_ms
+        )
+        return _snapshot_response(req.session_id, session, snapshot)
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+
+@router.post("/click", response_model=BrowserSessionResponse)
+async def click_browser(req: BrowserClickRequest) -> BrowserSessionResponse:
+    """Click an element in the current browser session."""
+    session = _get_browser_session(req.session_id)
+    try:
+        snapshot = await session.click(
+            req.selector,
+            timeout_ms=req.timeout_ms,
+            wait_until_after=req.wait_until_after,
+        )
+        return _snapshot_response(req.session_id, session, snapshot)
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+
+@router.post("/fill", response_model=BrowserSessionResponse)
+async def fill_browser(req: BrowserFillRequest) -> BrowserSessionResponse:
+    """Fill an input in the current browser session."""
+    session = _get_browser_session(req.session_id)
+    try:
+        snapshot = await session.fill(
+            req.selector,
+            req.value,
+            timeout_ms=req.timeout_ms,
+            submit=req.submit,
+        )
+        return _snapshot_response(req.session_id, session, snapshot)
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+
+@router.post("/extract", response_model=BrowserTextResponse)
+async def extract_browser_text(req: BrowserExtractRequest) -> BrowserTextResponse:
+    """Extract visible text from the page or a specific selector."""
+    session = _get_browser_session(req.session_id)
+    try:
+        snapshot = await session.snapshot()
+        text = await session.extract_text(
+            req.selector, timeout_ms=req.timeout_ms, max_length=req.max_length
+        )
+        return BrowserTextResponse(
+            session_id=req.session_id,
+            url=snapshot.get("url"),
+            title=snapshot.get("title"),
+            text=text,
+        )
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+
+@router.post("/screenshot", response_model=BrowserScreenshotResponse)
+async def screenshot_browser(req: BrowserScreenshotRequest) -> BrowserScreenshotResponse:
+    """Capture a PNG screenshot from the current browser session."""
+    session = _get_browser_session(req.session_id)
+    try:
+        snapshot = await session.snapshot()
+        png = await session.screenshot_png(full_page=req.full_page)
+        return BrowserScreenshotResponse(
+            session_id=req.session_id,
+            url=snapshot.get("url"),
+            title=snapshot.get("title"),
+            image_base64=base64.b64encode(png).decode("ascii"),
+        )
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+
+@router.post("/sessions/close", response_model=BrowserSessionResponse)
+async def close_browser_session(req: BrowserSessionRequest) -> BrowserSessionResponse:
+    """Close a browser automation session and release resources."""
+    session = _browser_sessions.pop(req.session_id, None)
+    if session is None:
+        raise HTTPException(status_code=404, detail="Browser automation sesija netika atrasta.")
+
+    try:
+        snapshot = await session.snapshot()
+    except _browser_operation_errors():
+        snapshot = {"url": None, "title": None}
+
+    try:
+        await session.close()
+    except _browser_operation_errors() as exc:
+        _raise_browser_http_error(exc)
+
+    return BrowserSessionResponse(
+        session_id=req.session_id,
+        active=False,
+        headless=session.headless,
+        viewport=session.viewport,
+        url=snapshot.get("url"),
+        title=snapshot.get("title"),
+    )

core-python/maris_core/code/__init__.py

@@ -0,0 +1 @@
+"""__init__ for code module."""

core-python/maris_core/code/execution_eval.py

@@ -0,0 +1,380 @@
+"""Execution-based code evaluation helpers for coder benchmarks."""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+import shutil
+import sqlite3
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+try:
+    import resource
+except ImportError:  # pragma: no cover - non-POSIX fallback
+    resource = None  # type: ignore[assignment]
+
+_CODE_BLOCK_RE = re.compile(r"```(?P<lang>[^\n`]*)\n(?P<code>.*?)```", re.DOTALL)
+DEFAULT_EXECUTION_MEMORY_LIMIT_MB = 512
+DEFAULT_EXECUTION_MAX_OUTPUT_CHARS = 12_000
+
+
+@dataclass(frozen=True, slots=True)
+class CodeExecutionSpec:
+    language: str
+    test_code: str = ""
+    timeout_seconds: float = 8.0
+    compile_only: bool = False
+    memory_limit_mb: int = DEFAULT_EXECUTION_MEMORY_LIMIT_MB
+    max_output_chars: int = DEFAULT_EXECUTION_MAX_OUTPUT_CHARS
+
+
+@dataclass(frozen=True, slots=True)
+class CodeExecutionResult:
+    language: str
+    available: bool
+    passed: bool
+    summary: str
+    exit_code: int | None = None
+    stdout: str = ""
+    stderr: str = ""
+
+
+def extract_code_block(text: str, language: str | None = None) -> str:
+    matches = list(_CODE_BLOCK_RE.finditer(text))
+    if not matches:
+        return text.strip()
+
+    normalized_language = (language or "").strip().lower()
+    if normalized_language:
+        for match in matches:
+            fence_language = match.group("lang").strip().lower()
+            if fence_language == normalized_language:
+                return match.group("code").strip()
+    return matches[0].group("code").strip()
+
+
+def evaluate_code_response(response_text: str, spec: CodeExecutionSpec) -> CodeExecutionResult:
+    language = spec.language.strip().lower()
+    code = extract_code_block(response_text, language=language)
+    if not code:
+        return CodeExecutionResult(
+            language=language,
+            available=True,
+            passed=False,
+            summary="Atbildē nav atrasts izpildāms koda bloks.",
+        )
+
+    if language == "python":
+        python_path = shutil.which("python3") or shutil.which("python")
+        if python_path is None:
+            return _unsupported_language_result(language, "python nav pieejams.")
+        command = (
+            [python_path, "-I", "-B", "-s", "main.py"]
+            if not spec.compile_only
+            else [python_path, "-I", "-B", "-s", "-m", "py_compile", "main.py"]
+        )
+        return _run_script_eval(
+            language=language,
+            command=command,
+            file_name="main.py",
+            source=_build_source(code, spec.test_code, "#"),
+            spec=spec,
+        )
+    if language in {"javascript", "js"}:
+        node_path = shutil.which("node")
+        if node_path is None:
+            return _unsupported_language_result(language, "node nav pieejams.")
+        command = (
+            [node_path, "main.js"] if not spec.compile_only else [node_path, "--check", "main.js"]
+        )
+        return _run_script_eval(
+            language=language,
+            command=command,
+            file_name="main.js",
+            source=_build_source(code, spec.test_code, "//"),
+            spec=spec,
+        )
+    if language in {"typescript", "ts"}:
+        return _run_typescript_eval(code, spec)
+    if language in {"bash", "sh"}:
+        bash_path = shutil.which("bash")
+        if bash_path is None:
+            return _unsupported_language_result(language, "bash nav pieejams.")
+        command = [bash_path, "main.sh"] if not spec.compile_only else [bash_path, "-n", "main.sh"]
+        return _run_script_eval(
+            language=language,
+            command=command,
+            file_name="main.sh",
+            source=_build_source(code, spec.test_code, "#"),
+            spec=spec,
+        )
+    if language == "rust":
+        return _run_rust_eval(code, spec)
+    if language == "sql":
+        return _run_sql_eval(code, spec)
+
+    return _unsupported_language_result(
+        language, "Valoda execution evals režīmā vēl nav atbalstīta."
+    )
+
+
+def _build_source(code: str, test_code: str, comment_prefix: str) -> str:
+    source = code.strip()
+    tests = test_code.strip()
+    if not tests:
+        return source + "\n"
+    return f"{source}\n\n{comment_prefix} execution harness\n{tests}\n"
+
+
+def _run_script_eval(
+    *,
+    language: str,
+    command: list[str],
+    file_name: str,
+    source: str,
+    spec: CodeExecutionSpec,
+) -> CodeExecutionResult:
+    with tempfile.TemporaryDirectory(prefix="maris-code-eval-") as tmp_dir:
+        workspace = Path(tmp_dir)
+        file_path = workspace / file_name
+        file_path.write_text(source, encoding="utf-8")
+        result = _run_command(command, cwd=workspace, spec=spec, language=language)
+        if result is None:
+            return CodeExecutionResult(
+                language=language,
+                available=True,
+                passed=True,
+                summary=f"{language} kods izpildījās veiksmīgi.",
+                exit_code=0,
+            )
+        return result
+
+
+def _run_typescript_eval(code: str, spec: CodeExecutionSpec) -> CodeExecutionResult:
+    tsc_path = shutil.which("tsc")
+    if tsc_path is None:
+        return _unsupported_language_result("typescript", "tsc nav pieejams.")
+    node_path = shutil.which("node")
+    if not spec.compile_only and node_path is None:
+        return _unsupported_language_result("typescript", "node nav pieejams TypeScript izpildei.")
+
+    with tempfile.TemporaryDirectory(prefix="maris-code-eval-") as tmp_dir:
+        workspace = Path(tmp_dir)
+        source_path = workspace / "main.ts"
+        source_path.write_text(_build_source(code, spec.test_code, "//"), encoding="utf-8")
+        compile_result = _run_command(
+            [
+                tsc_path,
+                "--pretty",
+                "false",
+                "--target",
+                "ES2020",
+                "--module",
+                "commonjs",
+                "main.ts",
+            ],
+            cwd=workspace,
+            spec=spec,
+            language="typescript",
+        )
+        if compile_result is not None:
+            return compile_result
+        if spec.compile_only:
+            return CodeExecutionResult(
+                language="typescript",
+                available=True,
+                passed=True,
+                summary="TypeScript kods veiksmīgi sakompilējās.",
+                exit_code=0,
+            )
+        run_result = _run_command(
+            [node_path, "main.js"], cwd=workspace, spec=spec, language="typescript"
+        )
+        if run_result is None:
+            return CodeExecutionResult(
+                language="typescript",
+                available=True,
+                passed=True,
+                summary="TypeScript kods veiksmīgi sakompilējās un izpildījās.",
+                exit_code=0,
+            )
+        return run_result
+
+
+def _run_rust_eval(code: str, spec: CodeExecutionSpec) -> CodeExecutionResult:
+    rustc_path = shutil.which("rustc")
+    if rustc_path is None:
+        return _unsupported_language_result("rust", "rustc nav pieejams.")
+    with tempfile.TemporaryDirectory(prefix="maris-code-eval-") as tmp_dir:
+        workspace = Path(tmp_dir)
+        source_path = workspace / "main.rs"
+        binary_path = workspace / "main"
+        source_path.write_text(_build_source(code, spec.test_code, "//"), encoding="utf-8")
+        compile_result = _run_command(
+            [rustc_path, "main.rs", "-o", str(binary_path)],
+            cwd=workspace,
+            spec=spec,
+            language="rust",
+        )
+        if compile_result is not None:
+            return compile_result
+        if spec.compile_only:
+            return CodeExecutionResult(
+                language="rust",
+                available=True,
+                passed=True,
+                summary="Rust kods veiksmīgi sakompilējās.",
+                exit_code=0,
+            )
+        run_result = _run_command([str(binary_path)], cwd=workspace, spec=spec, language="rust")
+        if run_result is None:
+            return CodeExecutionResult(
+                language="rust",
+                available=True,
+                passed=True,
+                summary="Rust kods veiksmīgi sakompilējās un izpildījās.",
+                exit_code=0,
+            )
+        return run_result
+
+
+def _run_sql_eval(code: str, spec: CodeExecutionSpec) -> CodeExecutionResult:
+    try:
+        with tempfile.TemporaryDirectory(prefix="maris-sql-eval-") as tmp_dir:
+            workspace = Path(tmp_dir)
+            connection = sqlite3.connect(":memory:")
+            try:
+                connection.execute("PRAGMA foreign_keys = ON")
+                script = _build_sql_script(code, spec.test_code, compile_only=spec.compile_only)
+                connection.executescript(script)
+            finally:
+                connection.close()
+                workspace.mkdir(parents=True, exist_ok=True)
+    except sqlite3.Error as exc:
+        return CodeExecutionResult(
+            language="sql",
+            available=True,
+            passed=False,
+            summary="SQL execution eval neizdevās.",
+            stderr=str(exc),
+        )
+    return CodeExecutionResult(
+        language="sql",
+        available=True,
+        passed=True,
+        summary="SQL skripts veiksmīgi validējās un izpildījās.",
+        exit_code=0,
+    )
+
+
+def _build_sql_script(code: str, test_code: str, *, compile_only: bool) -> str:
+    candidate = code.strip().rstrip(";")
+    harness = test_code.strip()
+    if harness and "{{CODE}}" in harness:
+        return harness.replace("{{CODE}}", candidate)
+    if compile_only:
+        if harness:
+            return f"{harness}\nEXPLAIN QUERY PLAN {candidate};\n"
+        return f"EXPLAIN QUERY PLAN {candidate};\n"
+    if harness:
+        return f"{harness}\n{candidate};\n"
+    return candidate + ";\n"
+
+
+def _run_command(
+    command: list[str],
+    *,
+    cwd: Path,
+    spec: CodeExecutionSpec,
+    language: str,
+) -> CodeExecutionResult | None:
+    try:
+        completed = subprocess.run(  # noqa: S603
+            command,
+            cwd=str(cwd),
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=spec.timeout_seconds,
+            stdin=subprocess.DEVNULL,
+            env=_build_isolated_env(cwd),
+            preexec_fn=_build_subprocess_preexec(spec),
+        )
+    except subprocess.TimeoutExpired as exc:
+        return CodeExecutionResult(
+            language=language,
+            available=True,
+            passed=False,
+            summary="Execution eval pārsniedza laika limitu.",
+            stdout=_truncate_output(exc.stdout or "", spec.max_output_chars),
+            stderr=_truncate_output(exc.stderr or "", spec.max_output_chars),
+        )
+    if completed.returncode == 0:
+        return None
+    return CodeExecutionResult(
+        language=language,
+        available=True,
+        passed=False,
+        summary="Execution eval neizdevās.",
+        exit_code=completed.returncode,
+        stdout=_truncate_output(completed.stdout, spec.max_output_chars),
+        stderr=_truncate_output(completed.stderr, spec.max_output_chars),
+    )
+
+
+def _build_isolated_env(workspace: Path) -> dict[str, str]:
+    env: dict[str, str] = {
+        "HOME": str(workspace),
+        "TMPDIR": str(workspace),
+        "TEMP": str(workspace),
+        "TMP": str(workspace),
+        "PYTHONNOUSERSITE": "1",
+        "PYTHONDONTWRITEBYTECODE": "1",
+        "PYTHONIOENCODING": "utf-8",
+        "NODE_DISABLE_COLORS": "1",
+        "CI": "1",
+    }
+    for key in ("PATH", "SYSTEMROOT", "SystemRoot", "WINDIR", "ComSpec"):
+        value = os.environ.get(key)
+        if value:
+            env[key] = value
+    return env
+
+
+def _build_subprocess_preexec(spec: CodeExecutionSpec):
+    if os.name != "posix" or resource is None:
+        return None
+
+    memory_limit_bytes = max(spec.memory_limit_mb, 64) * 1024 * 1024
+    cpu_limit_seconds = max(2, math.ceil(spec.timeout_seconds) + 1)
+
+    def _apply_limits() -> None:
+        os.setsid()
+        resource.setrlimit(resource.RLIMIT_CPU, (cpu_limit_seconds, cpu_limit_seconds))
+        resource.setrlimit(resource.RLIMIT_AS, (memory_limit_bytes, memory_limit_bytes))
+        resource.setrlimit(resource.RLIMIT_CORE, (0, 0))
+        resource.setrlimit(resource.RLIMIT_FSIZE, (8 * 1024 * 1024, 8 * 1024 * 1024))
+        resource.setrlimit(resource.RLIMIT_NOFILE, (64, 64))
+        if hasattr(resource, "RLIMIT_NPROC"):
+            resource.setrlimit(resource.RLIMIT_NPROC, (32, 32))
+
+    return _apply_limits
+
+
+def _truncate_output(value: str, max_chars: int) -> str:
+    if len(value) <= max_chars:
+        return value
+    return value[:max_chars] + "\n...[truncated]"
+
+
+def _unsupported_language_result(language: str, reason: str) -> CodeExecutionResult:
+    return CodeExecutionResult(
+        language=language,
+        available=False,
+        passed=False,
+        summary=reason,
+    )

core-python/maris_core/code/fix_code.py

@@ -0,0 +1,5 @@
+"""Koda labošana — atsevišķs modulis."""
+
+from maris_core.code.generate_code import CodeResponse, FixCodeRequest, fix_code
+
+__all__ = ["fix_code", "FixCodeRequest", "CodeResponse"]

core-python/maris_core/code/generate_code.py

@@ -0,0 +1,689 @@
+"""Koda ģenerēšana un labošana ar Qwen3."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import zipfile
+from pathlib import Path
+from uuid import uuid4
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel, Field
+
+from maris_core.text.generate import (
+    DEFAULT_MAX_NEW_TOKENS,
+    call_generation_pipeline,
+    complete_with_hf_fallback,
+    get_pipeline,
+)
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+WORKSPACE_ARTIFACT_ROOT = Path("/tmp/maris-ai/generated-projects")
+DEFAULT_REPO_ROOT = Path(__file__).resolve().parents[3]
+_MAX_REPO_CONTEXT_FILES = 6
+_MAX_REPO_CONTEXT_CHARS = 1800
+_FENCED_BLOCK_PATTERN = re.compile(
+    r"```(?P<label>[^\n`]*)\n(?P<body>.*?)```",
+    flags=re.DOTALL,
+)
+_EDIT_INTENT_PATTERN = re.compile(
+    r"\b(edit|modify|update|refactor|fix|patch|rewrite|change|cleanup|labo|salabo|rediģē|pārstrādā|uzlabo)\b",
+    flags=re.IGNORECASE,
+)
+_PATH_HINT_PATTERN = re.compile(r"(?P<path>(?:/|\./|\.\./)[^\s,;:()\[\]{}<>]+)")
+_REPO_RELATIVE_HINT_PATTERN = re.compile(
+    r"(?P<path>(?:[A-Za-z0-9_.-]+/)+[A-Za-z0-9_.-]+\.[A-Za-z0-9_.-]+)"
+)
+_STACK_KEYWORDS: dict[str, tuple[str, ...]] = {
+    "nextjs": ("next.js", "nextjs", " app router", "next app"),
+    "react": ("react", "vite", "tsx component"),
+    "rust": ("rust", "cargo", "actix", "axum"),
+    "python": ("python", "fastapi", "flask", "django", "pytest"),
+    "web": ("html", "css", "landing page", "calculator", "kalkulator", "web app", "web-app"),
+}
+_STACK_DISPLAY_NAMES = {
+    "nextjs": "Next.js (TypeScript)",
+    "react": "React (TypeScript)",
+    "rust": "Rust",
+    "python": "Python",
+    "web": "HTML/CSS/JavaScript",
+}
+_STACK_ENTRYPOINTS = {
+    "nextjs": "app/page.tsx",
+    "react": "src/App.tsx",
+    "rust": "src/main.rs",
+    "python": "src/main.py",
+    "web": "index.html",
+}
+
+
+class CodeRequest(BaseModel):
+    prompt: str
+    language: str = "Python"
+    context: str = ""
+    repo_path: str | None = None
+    fallback_model: str | None = None
+    max_new_tokens: int = Field(default=DEFAULT_MAX_NEW_TOKENS, ge=32)
+
+
+class FixCodeRequest(BaseModel):
+    code: str
+    error_message: str = ""
+    language: str = "Python"
+
+
+class ProjectFile(BaseModel):
+    path: str
+    content: str
+    absolute_path: str | None = None
+
+
+class CodeResponse(BaseModel):
+    code: str
+    explanation: str
+    language: str
+    detected_stack: str
+    files: list[ProjectFile] = Field(default_factory=list)
+    workspace_artifact_dir: str | None = None
+    bundle_path: str | None = None
+    entrypoint: str | None = None
+    repo_path: str | None = None
+
+
+class RepoContext(BaseModel):
+    repo_path: str
+    files: list[str] = Field(default_factory=list)
+
+
+def _extract_code_block(text: str, language: str) -> tuple[str, str]:
+    """Izvelk koda bloku un paskaidrojumu no LLM atbildes."""
+    del language
+    lines = text.split("\n")
+    code_lines: list[str] = []
+    explanation_lines: list[str] = []
+    in_code = False
+
+    for line in lines:
+        if line.strip().startswith("```"):
+            in_code = not in_code
+            continue
+        if in_code:
+            code_lines.append(line)
+        else:
+            explanation_lines.append(line)
+
+    code = "\n".join(code_lines).strip()
+    explanation = "\n".join(explanation_lines).strip()
+
+    if not code:
+        code = text.strip()
+        explanation = ""
+
+    return code, explanation
+
+
+def _extract_structured_project_payload(text: str) -> dict[str, object] | None:
+    candidates: list[str] = []
+    stripped = text.strip()
+    if stripped.startswith("{") and stripped.endswith("}"):
+        candidates.append(stripped)
+    for match in _FENCED_BLOCK_PATTERN.finditer(text):
+        label = match.group("label").strip().lower()
+        if "json" in label:
+            candidates.append(match.group("body").strip())
+    for candidate in candidates:
+        try:
+            payload = json.loads(candidate)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict) and isinstance(payload.get("files"), list):
+            return payload
+    return None
+
+
+def _sanitize_relative_path(path: str) -> str:
+    candidate = Path(path.strip().replace("\\", "/"))
+    cleaned_parts = [part for part in candidate.parts if part not in {"", ".", ".."}]
+    if not cleaned_parts:
+        return "main.txt"
+    return Path(*cleaned_parts).as_posix()
+
+
+def _slugify_prompt(prompt: str) -> str:
+    tokens = re.findall(r"[a-z0-9]+", prompt.lower())
+    return "-".join(tokens[:6]) or "generated-project"
+
+
+def _looks_like_repo_edit_request(prompt: str) -> bool:
+    return bool(_EDIT_INTENT_PATTERN.search(prompt))
+
+
+def _extract_repo_path_from_prompt(prompt: str) -> Path | None:
+    for match in _PATH_HINT_PATTERN.finditer(prompt):
+        candidate = Path(match.group("path")).expanduser()
+        try:
+            resolved = candidate.resolve()
+        except OSError:
+            continue
+        if resolved.is_file():
+            resolved = resolved.parent
+        if resolved.is_dir():
+            return resolved
+    return None
+
+
+def _resolve_repo_path(raw_repo_path: str | None, prompt: str) -> Path | None:
+    if raw_repo_path:
+        candidate = Path(raw_repo_path).expanduser()
+        try:
+            resolved = candidate.resolve()
+        except OSError:
+            resolved = candidate
+        if resolved.is_file():
+            resolved = resolved.parent
+        if resolved.is_dir():
+            return resolved
+
+    extracted = _extract_repo_path_from_prompt(prompt)
+    if extracted is not None:
+        return extracted
+
+    if _looks_like_repo_edit_request(prompt) and DEFAULT_REPO_ROOT.exists():
+        return DEFAULT_REPO_ROOT
+    return None
+
+
+def _read_json(path: Path) -> dict[str, object]:
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+
+
+def _detect_stack(prompt: str, requested_language: str, repo_path: Path | None) -> str:
+    if repo_path is not None:
+        package_json = _read_json(repo_path / "package.json")
+        dependencies = {
+            **({str(k): v for k, v in package_json.get("dependencies", {}).items()} if isinstance(package_json.get("dependencies"), dict) else {}),
+            **({str(k): v for k, v in package_json.get("devDependencies", {}).items()} if isinstance(package_json.get("devDependencies"), dict) else {}),
+        }
+        if (repo_path / "next.config.js").exists() or (repo_path / "next.config.mjs").exists() or "next" in dependencies:
+            return "nextjs"
+        if "react" in dependencies or (repo_path / "src/App.tsx").exists() or (repo_path / "src/main.tsx").exists():
+            return "react"
+        if (repo_path / "Cargo.toml").exists() or (repo_path / "src/main.rs").exists():
+            return "rust"
+        if (repo_path / "pyproject.toml").exists() or (repo_path / "requirements.txt").exists() or (repo_path / "src/main.py").exists():
+            return "python"
+
+    normalized_prompt = f" {prompt.lower()} "
+    for stack, keywords in _STACK_KEYWORDS.items():
+        if any(keyword in normalized_prompt for keyword in keywords):
+            return stack
+
+    normalized_language = requested_language.strip().lower()
+    if "next" in normalized_language:
+        return "nextjs"
+    if "html/css/javascript" in normalized_language:
+        return "web"
+    if "react" in normalized_language or "typescript" in normalized_language:
+        return "react"
+    if "javascript" in normalized_language:
+        return "web"
+    if "rust" in normalized_language:
+        return "rust"
+    return "python"
+
+
+def _display_language_for_stack(requested_language: str, detected_stack: str) -> str:
+    if requested_language.strip() and requested_language.strip().lower() != "python":
+        if detected_stack in {"nextjs", "react"}:
+            return _STACK_DISPLAY_NAMES[detected_stack]
+        if detected_stack == "rust" and "rust" in requested_language.strip().lower():
+            return "Rust"
+        if detected_stack == "python" and "python" in requested_language.strip().lower():
+            return "Python"
+    return _STACK_DISPLAY_NAMES.get(detected_stack, requested_language)
+
+
+def _default_entrypoint_for_stack(detected_stack: str, repo_path: Path | None) -> str:
+    if repo_path is not None:
+        candidates = {
+            "nextjs": ["app/page.tsx", "pages/index.tsx", "src/app/page.tsx"],
+            "react": ["src/App.tsx", "src/main.tsx", "src/App.jsx"],
+            "rust": ["src/main.rs"],
+            "python": ["src/main.py", "main.py", "app/main.py"],
+        }.get(detected_stack, [])
+        for candidate in candidates:
+            if (repo_path / candidate).exists():
+                return candidate
+    return _STACK_ENTRYPOINTS.get(detected_stack, "main.py")
+
+
+def _stack_scaffold_templates(detected_stack: str) -> dict[str, str]:
+    if detected_stack == "nextjs":
+        package_json = {
+            "name": "maris-next-app",
+            "private": True,
+            "scripts": {"dev": "next dev", "build": "next build", "start": "next start"},
+            "dependencies": {"next": "15.0.0", "react": "18.3.1", "react-dom": "18.3.1"},
+            "devDependencies": {"typescript": "5.6.3", "@types/react": "18.3.3", "@types/node": "22.7.4"},
+        }
+        return {
+            "package.json": json.dumps(package_json, ensure_ascii=False, indent=2) + "\n",
+            "tsconfig.json": json.dumps(
+                {
+                    "compilerOptions": {
+                        "target": "ES2022",
+                        "lib": ["dom", "dom.iterable", "es2022"],
+                        "allowJs": False,
+                        "skipLibCheck": True,
+                        "strict": True,
+                        "noEmit": True,
+                        "module": "esnext",
+                        "moduleResolution": "bundler",
+                        "resolveJsonModule": True,
+                        "isolatedModules": True,
+                        "jsx": "preserve",
+                        "incremental": True,
+                    },
+                    "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+                    "exclude": ["node_modules"],
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+            + "\n",
+            "next-env.d.ts": '/// <reference types="next" />\n/// <reference types="next/image-types/global" />\n',
+            "next.config.mjs": "/** @type {import('next').NextConfig} */\nconst nextConfig = {};\n\nexport default nextConfig;\n",
+            "app/layout.tsx": "export default function RootLayout({ children }: { children: React.ReactNode }) {\n  return (\n    <html lang=\"en\">\n      <body>{children}</body>\n    </html>\n  );\n}\n",
+            "app/page.tsx": "export default function HomePage() {\n  return <main>Maris Next.js app</main>;\n}\n",
+        }
+    if detected_stack == "react":
+        package_json = {
+            "name": "maris-react-app",
+            "private": True,
+            "type": "module",
+            "scripts": {"dev": "vite", "build": "vite build", "preview": "vite preview"},
+            "dependencies": {"react": "18.3.1", "react-dom": "18.3.1"},
+            "devDependencies": {
+                "typescript": "5.6.3",
+                "vite": "5.4.8",
+                "@vitejs/plugin-react": "4.3.1",
+                "@types/react": "18.3.3",
+                "@types/react-dom": "18.3.0",
+            },
+        }
+        return {
+            "package.json": json.dumps(package_json, ensure_ascii=False, indent=2) + "\n",
+            "tsconfig.json": json.dumps(
+                {
+                    "compilerOptions": {
+                        "target": "ES2020",
+                        "useDefineForClassFields": True,
+                        "lib": ["DOM", "DOM.Iterable", "ES2020"],
+                        "allowJs": False,
+                        "skipLibCheck": True,
+                        "esModuleInterop": True,
+                        "allowSyntheticDefaultImports": True,
+                        "strict": True,
+                        "module": "ESNext",
+                        "moduleResolution": "bundler",
+                        "resolveJsonModule": True,
+                        "isolatedModules": True,
+                        "noEmit": True,
+                        "jsx": "react-jsx",
+                    },
+                    "include": ["src"],
+                },
+                ensure_ascii=False,
+                indent=2,
+            )
+            + "\n",
+            "vite.config.ts": "import { defineConfig } from 'vite';\nimport react from '@vitejs/plugin-react';\n\nexport default defineConfig({\n  plugins: [react()],\n});\n",
+            "index.html": "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>Maris React App</title>\n  </head>\n  <body>\n    <div id=\"root\"></div>\n    <script type=\"module\" src=\"/src/main.tsx\"></script>\n  </body>\n</html>\n",
+            "src/main.tsx": "import React from 'react';\nimport ReactDOM from 'react-dom/client';\nimport App from './App';\n\nReactDOM.createRoot(document.getElementById('root')!).render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>,\n);\n",
+            "src/App.tsx": "export default function App() {\n  return <main>Maris React app</main>;\n}\n",
+        }
+    if detected_stack == "rust":
+        return {
+            "Cargo.toml": "[package]\nname = \"maris-rust-app\"\nversion = \"0.1.0\"\nedition = \"2021\"\n\n[dependencies]\n",
+            "src/main.rs": 'fn main() {\n    println!("Hello from Maris Rust app");\n}\n',
+        }
+    if detected_stack == "web":
+        return {
+            "index.html": "<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>Maris Web App</title>\n  </head>\n  <body>\n    <main>Maris web artifact</main>\n  </body>\n</html>\n",
+        }
+    return {
+        "pyproject.toml": "[project]\nname = \"maris-python-app\"\nversion = \"0.1.0\"\ndescription = \"Generated by Maris AI\"\nrequires-python = \">=3.11\"\n\n[project.scripts]\nmaris-app = \"src.main:main\"\n",
+        "src/main.py": "def main() -> None:\n    print('Hello from Maris Python app')\n\n\nif __name__ == '__main__':\n    main()\n",
+    }
+
+
+def _normalize_files(files: list[ProjectFile]) -> list[ProjectFile]:
+    normalized: dict[str, ProjectFile] = {}
+    for file in files:
+        path = _sanitize_relative_path(file.path)
+        normalized[path] = ProjectFile(path=path, content=file.content, absolute_path=file.absolute_path)
+    return list(normalized.values())
+
+
+def _ensure_stack_scaffold(
+    files: list[ProjectFile],
+    *,
+    detected_stack: str,
+    entrypoint: str | None,
+    repo_path: Path | None,
+) -> tuple[list[ProjectFile], str]:
+    normalized_files = _normalize_files(files)
+    resolved_entrypoint = _sanitize_relative_path(
+        entrypoint or _default_entrypoint_for_stack(detected_stack, repo_path)
+    )
+
+    if repo_path is not None:
+        if len(normalized_files) == 1:
+            only_file = normalized_files[0]
+            if only_file.path != resolved_entrypoint:
+                normalized_files[0] = ProjectFile(path=resolved_entrypoint, content=only_file.content)
+        return normalized_files, resolved_entrypoint
+
+    templates = _stack_scaffold_templates(detected_stack)
+    file_map = {file.path: file for file in normalized_files}
+    fallback_paths = {"main.py", "src/main.py", "src/main.rs", "src/App.tsx", "app/page.tsx", "index.html"}
+    if len(file_map) == 1:
+        only_path, only_file = next(iter(file_map.items()))
+        if only_path in fallback_paths and only_path != resolved_entrypoint:
+            file_map.pop(only_path)
+            file_map[resolved_entrypoint] = ProjectFile(path=resolved_entrypoint, content=only_file.content)
+
+    for path, content in templates.items():
+        if path not in file_map:
+            file_map[path] = ProjectFile(path=path, content=content)
+
+    ordered_paths = list(templates.keys()) + [path for path in file_map if path not in templates]
+    ordered_files = [file_map[path] for path in ordered_paths]
+    return ordered_files, resolved_entrypoint
+
+
+def _extract_project_files(
+    text: str,
+    *,
+    language: str,
+    fallback_entrypoint: str = "main.py",
+) -> tuple[list[ProjectFile], str | None, str]:
+    payload = _extract_structured_project_payload(text)
+    if payload is not None:
+        files_payload = payload.get("files")
+        files: list[ProjectFile] = []
+        if isinstance(files_payload, list):
+            for item in files_payload:
+                if not isinstance(item, dict):
+                    continue
+                raw_path = str(item.get("path", "")).strip()
+                raw_content = str(item.get("content", ""))
+                if not raw_path or not raw_content.strip():
+                    continue
+                files.append(
+                    ProjectFile(
+                        path=_sanitize_relative_path(raw_path),
+                        content=raw_content,
+                    )
+                )
+        entrypoint = payload.get("entrypoint") or payload.get("primary_file")
+        explanation = str(payload.get("explanation") or payload.get("summary") or "").strip()
+        return files, (
+            _sanitize_relative_path(str(entrypoint)) if isinstance(entrypoint, str) and entrypoint else None
+        ), explanation
+
+    code, explanation = _extract_code_block(text, language)
+    if not code.strip():
+        return [], None, explanation
+    return [ProjectFile(path=fallback_entrypoint, content=code)], fallback_entrypoint, explanation
+
+
+def _select_primary_code(files: list[ProjectFile], entrypoint: str | None) -> str:
+    if entrypoint:
+        for file in files:
+            if file.path == entrypoint:
+                return file.content
+    return files[0].content if files else ""
+
+
+def _extract_repo_relative_hints(prompt: str, repo_path: Path) -> list[str]:
+    hinted_paths: list[str] = []
+    repo_root = repo_path.resolve()
+    for pattern in (_PATH_HINT_PATTERN, _REPO_RELATIVE_HINT_PATTERN):
+        for match in pattern.finditer(prompt):
+            raw_path = match.group("path").strip()
+            candidate = repo_path / raw_path if not raw_path.startswith("/") else Path(raw_path)
+            try:
+                resolved = candidate.resolve()
+            except OSError:
+                continue
+            try:
+                relative_path = resolved.relative_to(repo_root).as_posix()
+            except ValueError:
+                continue
+            if resolved.is_file() and relative_path not in hinted_paths:
+                hinted_paths.append(relative_path)
+    return hinted_paths
+
+
+def _repo_context_candidates(repo_path: Path, detected_stack: str, prompt: str = "") -> list[str]:
+    candidates = _extract_repo_relative_hints(prompt, repo_path) + ["README.md"]
+    candidates.extend(
+        {
+            "nextjs": ["package.json", "tsconfig.json", "next.config.mjs", "app/layout.tsx", "app/page.tsx", "pages/index.tsx"],
+            "react": ["package.json", "tsconfig.json", "vite.config.ts", "index.html", "src/main.tsx", "src/App.tsx"],
+            "rust": ["Cargo.toml", "src/main.rs", "src/lib.rs"],
+            "python": ["pyproject.toml", "requirements.txt", "src/main.py", "main.py", "app/main.py"],
+            "web": ["index.html"],
+        }.get(detected_stack, [])
+    )
+    existing: list[str] = []
+    for candidate in candidates:
+        if (repo_path / candidate).exists() and candidate not in existing:
+            existing.append(candidate)
+        if len(existing) >= _MAX_REPO_CONTEXT_FILES:
+            break
+    return existing
+
+
+def _build_repo_context(repo_path: Path | None, detected_stack: str, prompt: str = "") -> RepoContext | None:
+    if repo_path is None or not repo_path.exists():
+        return None
+    files = _repo_context_candidates(repo_path, detected_stack, prompt)
+    if not files:
+        return RepoContext(repo_path=str(repo_path), files=[])
+    excerpts: list[str] = []
+    for relative_path in files:
+        try:
+            content = (repo_path / relative_path).read_text(encoding="utf-8")
+        except OSError:
+            continue
+        excerpts.append(
+            f"[FILE {relative_path}]\n{content[:_MAX_REPO_CONTEXT_CHARS].strip()}"
+        )
+    return RepoContext(repo_path=str(repo_path), files=files) if not excerpts else RepoContext(
+        repo_path=str(repo_path),
+        files=["\n\n".join(excerpts)],
+    )
+
+
+def _build_system_prompt(
+    *,
+    language: str,
+    detected_stack: str,
+    repo_context: RepoContext | None,
+) -> str:
+    stack_label = _STACK_DISPLAY_NAMES.get(detected_stack, language)
+    prompt = (
+        f"Tu esi Maris AI — eksperts programmētājs. Uzraksti {language} kodu ar pareizu {stack_label} projekta struktūru. "
+        "Dod production-ready risinājumu ar drošiem noklusējumiem, ievades validāciju un saprātīgu kļūdu apstrādi, ja tas attiecas uz uzdevumu. "
+        "Nepiedāvā pseidokodu, ja vien lietotājs to tieši neprasa. "
+        "Atbildi ar īsu paskaidrojumu, kurā nosauc edge cases un kā risinājumu pārbaudīt. "
+        "Ja pieprasījums ir par lietotni, UI vai workspace artefaktiem, atdod pilnu izpildāmu artefaktu. "
+        "Kad risinājums satur vienu vai vairākus failus, atbildi ar vienu ```json``` bloku formā "
+        '{"explanation":"...","entrypoint":"...","files":[{"path":"...","content":"..."}]} '
+        "un pārliecinies, ka files satur gala failus ar reālu saturu bez TODO placeholderiem. "
+        f"Primāri mērķē uz {stack_label} stacku un izmanto šim stackam idiomātiskus failu nosaukumus."
+    )
+    if repo_context is not None:
+        prompt += (
+            " Šī ir repo-aware rediģēšana esošam projektam: izmanto precīzus repo-relatīvos failu ceļus, "
+            "rediģē tikai nepieciešamos failus, saglabā esošo projekta struktūru un, ja prompt piesauc konkrētus failus, balsti risinājumu tieši uz tiem."
+        )
+    return prompt
+
+
+def _materialize_workspace_artifacts(
+    files: list[ProjectFile],
+    *,
+    prompt: str,
+) -> str | None:
+    if not files:
+        return None
+    artifact_dir = WORKSPACE_ARTIFACT_ROOT / f"{_slugify_prompt(prompt)}-{uuid4().hex[:8]}"
+    artifact_dir.mkdir(parents=True, exist_ok=True)
+    artifact_root = artifact_dir.resolve()
+    for file in files:
+        relative = Path(_sanitize_relative_path(file.path))
+        target = (artifact_root / relative).resolve()
+        if not str(target).startswith(str(artifact_root)):
+            raise HTTPException(status_code=400, detail="Nederīgs ģenerētā faila ceļš.")
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(file.content, encoding="utf-8")
+        file.absolute_path = str(target)
+    return str(artifact_root)
+
+
+def _create_bundle_zip(workspace_artifact_dir: str | None) -> str | None:
+    if not workspace_artifact_dir:
+        return None
+    artifact_root = Path(workspace_artifact_dir)
+    if not artifact_root.exists():
+        return None
+    bundle_path = artifact_root.with_suffix(".zip")
+    with zipfile.ZipFile(bundle_path, mode="w", compression=zipfile.ZIP_DEFLATED) as bundle:
+        for path in sorted(artifact_root.rglob("*")):
+            if path.is_file():
+                bundle.write(path, arcname=path.relative_to(artifact_root))
+    return str(bundle_path)
+
+
+@router.post("/generate", response_model=CodeResponse)
+async def generate_code(req: CodeRequest) -> CodeResponse:
+    """Ģenerē kodu pēc apraksta."""
+    from maris_core.utils.hf_integration import HFIntegration
+
+    hf = HFIntegration()
+    repo_path = _resolve_repo_path(req.repo_path, req.prompt)
+    detected_stack = _detect_stack(req.prompt, req.language, repo_path)
+    resolved_language = _display_language_for_stack(req.language, detected_stack)
+    repo_context = _build_repo_context(repo_path, detected_stack, req.prompt)
+    fallback_entrypoint = _default_entrypoint_for_stack(detected_stack, repo_path)
+    system_prompt = _build_system_prompt(
+        language=resolved_language,
+        detected_stack=detected_stack,
+        repo_context=repo_context,
+    )
+
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": req.prompt},
+    ]
+
+    if repo_context is not None:
+        repo_context_content = (
+            f"Repo sakne: {repo_context.repo_path}\n"
+            f"Esošie svarīgie faili: {', '.join(_repo_context_candidates(repo_path or DEFAULT_REPO_ROOT, detected_stack, req.prompt)) or 'nav'}"
+        )
+        if repo_context.files:
+            repo_context_content += f"\n\n{repo_context.files[0]}"
+        messages.insert(1, {"role": "user", "content": repo_context_content})
+
+    if req.context:
+        messages.insert(1, {"role": "user", "content": f"Konteksts:\n{req.context}"})
+
+    pipe = get_pipeline()
+    raw_response: str | None = None
+    if pipe is not None:
+        try:
+            out = call_generation_pipeline(
+                pipe,
+                messages,
+                max_new_tokens=req.max_new_tokens,
+                temperature=0.2,
+            )
+            raw_response = out[0]["generated_text"][-1]["content"]
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Koda ģenerēšanas kļūda: %s", exc)
+
+    if raw_response is None:
+        fallback_result = complete_with_hf_fallback(
+            messages,
+            fallback_model=req.fallback_model,
+            max_new_tokens=req.max_new_tokens,
+            temperature=0.2,
+        )
+        if fallback_result is not None:
+            _, raw_response = fallback_result
+        else:
+            raise HTTPException(
+                status_code=503,
+                detail="Maris AI koda ģenerēšana šobrīd nav pieejama.",
+            )
+
+    files, entrypoint, structured_explanation = _extract_project_files(
+        raw_response,
+        language=resolved_language,
+        fallback_entrypoint=fallback_entrypoint,
+    )
+    files, entrypoint = _ensure_stack_scaffold(
+        files,
+        detected_stack=detected_stack,
+        entrypoint=entrypoint,
+        repo_path=repo_path,
+    )
+    code, explanation = _extract_code_block(raw_response, resolved_language)
+    if files:
+        code = _select_primary_code(files, entrypoint)
+    if structured_explanation:
+        explanation = structured_explanation
+    workspace_artifact_dir = _materialize_workspace_artifacts(files, prompt=req.prompt)
+    bundle_path = _create_bundle_zip(workspace_artifact_dir)
+    detected_stack_label = _STACK_DISPLAY_NAMES.get(detected_stack, detected_stack)
+    await hf.save_generation(
+        "code",
+        req.prompt,
+        {
+            "language": resolved_language,
+            "detected_stack": detected_stack_label,
+            "repo_path": str(repo_path) if repo_path is not None else None,
+            "fallback_model": req.fallback_model,
+        },
+    )
+
+    return CodeResponse(
+        code=code,
+        explanation=explanation,
+        language=resolved_language,
+        detected_stack=detected_stack_label,
+        files=files,
+        workspace_artifact_dir=workspace_artifact_dir,
+        bundle_path=bundle_path,
+        entrypoint=entrypoint,
+        repo_path=str(repo_path) if repo_path is not None else None,
+    )
+
+
+@router.post("/fix", response_model=CodeResponse)
+async def fix_code(req: FixCodeRequest) -> CodeResponse:
+    """Labo kļūdainu kodu."""
+    prompt = f"Labo šo {req.language} kodu:\n```\n{req.code}\n```" + (
+        f"\nKļūda: {req.error_message}" if req.error_message else ""
+    )
+    return await generate_code(CodeRequest(prompt=prompt, language=req.language))

core-python/maris_core/data/__init__.py

@@ -0,0 +1 @@
+"""__init__ for data module."""

core-python/maris_core/data/augment.py

@@ -0,0 +1,123 @@
+"""Datu papildināšana (augmentation)."""
+
+from __future__ import annotations
+
+import math
+import random
+import re
+
+WORD_RE = re.compile(r"\b[\w'-]+\b", re.UNICODE)
+SYNONYM_MAP: dict[str, tuple[str, ...]] = {
+    "ātrs": ("žigls", "straujš"),
+    "attēls": ("bilde", "vizualizācija"),
+    "bilde": ("attēls",),
+    "big": ("large", "sizable"),
+    "code": ("program", "source"),
+    "create": ("build", "make"),
+    "fast": ("quick", "rapid"),
+    "generate": ("produce", "create"),
+    "good": ("solid", "reliable"),
+    "idea": ("concept", "approach"),
+    "image": ("picture", "visual"),
+    "intelligent": ("smart", "capable"),
+    "liels": ("apjomīgs", "ievērojams"),
+    "mazs": ("neliels", "kompakts"),
+    "prompt": ("instruction", "request"),
+    "quick": ("fast", "rapid"),
+    "small": ("compact", "lightweight"),
+    "smart": ("capable", "intelligent"),
+    "strong": ("robust", "powerful"),
+    "text": ("content", "message"),
+}
+BACK_TRANSLATION_MAP: dict[str, dict[str, str]] = {
+    "en": {
+        "because": "since",
+        "create": "build",
+        "fast": "quick",
+        "good": "solid",
+        "help": "assist",
+        "plan": "outline",
+    },
+    "lv": {
+        "ātrs": "žigls",
+        "izveidot": "radīt",
+        "labs": "stabils",
+        "palīdzēt": "atbalstīt",
+        "plāns": "ieceres plāns",
+    },
+}
+
+
+def _match_case(source: str, replacement: str) -> str:
+    if source.isupper():
+        return replacement.upper()
+    if source[:1].isupper():
+        return replacement.capitalize()
+    return replacement
+
+
+def _lookup_synonym(word: str) -> str | None:
+    synonyms = SYNONYM_MAP.get(word.casefold())
+    if not synonyms:
+        return None
+    return _match_case(word, random.choice(synonyms))
+
+
+def random_synonym_swap(text: str, rate: float = 0.1) -> str:
+    """Aizstāj daļu vārdu ar iebūvētiem sinonīmiem bez ārējām atkarībām."""
+    if not text.strip():
+        return text
+
+    words = list(WORD_RE.finditer(text))
+    if not words:
+        return text
+
+    candidates = [
+        (match.start(), match.end(), synonym)
+        for match in words
+        if (synonym := _lookup_synonym(match.group(0))) is not None
+    ]
+    if not candidates or rate <= 0:
+        return text
+
+    sample_size = min(len(candidates), max(1, math.ceil(len(words) * min(rate, 1.0))))
+    selected = {
+        (start, end): replacement
+        for start, end, replacement in random.sample(candidates, sample_size)
+    }
+
+    parts: list[str] = []
+    cursor = 0
+    for match in words:
+        span = (match.start(), match.end())
+        replacement = selected.get(span)
+        if replacement is None:
+            continue
+        parts.append(text[cursor : match.start()])
+        parts.append(replacement)
+        cursor = match.end()
+    if cursor == 0:
+        return text
+
+    parts.append(text[cursor:])
+    return "".join(parts)
+
+
+def back_translate(text: str, lang: str = "en") -> str:
+    """Viegls offline paraphrase fallback vietā, kur nav tulkošanas API."""
+    if not text.strip():
+        return text
+
+    replacements = BACK_TRANSLATION_MAP.get(lang.strip().lower(), {})
+    augmented = text
+    for source, target in replacements.items():
+        augmented = re.sub(
+            rf"\b{re.escape(source)}\b",
+            lambda match, replacement=target: _match_case(match.group(0), replacement),
+            augmented,
+            flags=re.IGNORECASE,
+        )
+
+    if augmented == text:
+        return random_synonym_swap(text, rate=0.2)
+    return augmented

core-python/maris_core/data/datasets.py

@@ -0,0 +1,561 @@
+"""Datasets konfigurācija un ielāde."""
+
+from __future__ import annotations
+
+import errno
+import json
+import logging
+import os
+import tempfile
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any
+
+from maris_core.data.preprocessing import record_to_training_text
+from maris_core.utils.env import get_env_any, get_env_any_or_default
+
+logger = logging.getLogger(__name__)
+
+_SUPPORTED_DATASET_FORMATS = {
+    ".json": "json",
+    ".jsonl": "json",
+    ".csv": "csv",
+    ".parquet": "parquet",
+}
+
+
+class HFDatasetError(FileNotFoundError):
+    """Atmiņas repozitorija konfigurācijas vai satura kļūda."""
+
+    def __init__(self, message: str, *, discovered_files: list[str] | None = None) -> None:
+        super().__init__(message)
+        self.discovered_files = discovered_files or []
+
+
+def _iter_exception_chain(exc: Exception) -> Iterator[BaseException]:
+    """Iziet cauri izņēmuma cēloņu ķēdei bez cikliem."""
+    pending: list[BaseException] = [exc]
+    seen: set[int] = set()
+
+    while pending:
+        current = pending.pop()
+        current_id = id(current)
+        if current_id in seen:
+            continue
+        seen.add(current_id)
+        yield current
+
+        cause = getattr(current, "__cause__", None)
+        context = getattr(current, "__context__", None)
+        if cause is not None:
+            pending.append(cause)
+        if context is not None:
+            pending.append(context)
+
+
+def _is_empty_dataset_error(exc: Exception) -> bool:
+    """Nosaka, vai repozitorijam trūkst tieši ielādējamu datu failu."""
+    markers = (
+        "doesn't contain any data files",
+        "No (supported) data files found in",
+    )
+    return any(
+        current.__class__.__name__ == "EmptyDatasetError"
+        or any(marker in str(current) for marker in markers)
+        for current in _iter_exception_chain(exc)
+    )
+
+
+def _is_schema_cast_error(exc: Exception) -> bool:
+    """Nosaka, vai JSON loader nokrīt uz mainīgu objektu shēmu."""
+    markers = (
+        "Couldn't cast",
+        "Couldn't cast array of type",
+    )
+    return any(
+        any(marker in str(current) for marker in markers) for current in _iter_exception_chain(exc)
+    )
+
+
+def _is_dataset_generation_error(exc: Exception) -> bool:
+    """Nosaka, vai datasets slānis meta ģenerisku DatasetGenerationError."""
+    return any(
+        current.__class__.__name__ == "DatasetGenerationError"
+        for current in _iter_exception_chain(exc)
+    )
+
+
+def _should_fallback_to_snapshot(exc: Exception) -> bool:
+    """Nosaka, vai jāizmanto snapshot-based datu ielāde apmācībai."""
+    return (
+        _is_empty_dataset_error(exc)
+        or _is_schema_cast_error(exc)
+        or _is_dataset_generation_error(exc)
+    )
+
+
+def _is_hf_cache_lock_io_error(exc: Exception) -> bool:
+    """Nosaka, vai Hugging Face cache lock failu sistēmā radās I/O kļūda."""
+    for current in _iter_exception_chain(exc):
+        if not isinstance(current, OSError):
+            continue
+
+        message = str(current)
+        filename = os.fspath(getattr(current, "filename", "") or "")
+        details = " ".join(part for part in (filename, message) if part).lower()
+        if "huggingface" not in details and "datasets--" not in details:
+            continue
+        if "lock" not in details:
+            continue
+        if current.errno == errno.EIO or "input/output error" in details:
+            return True
+    return False
+
+
+def _resolve_hf_cache_recovery_dir() -> str:
+    """Atgriež drošu fallback cache direktoriju HF lejupielādēm."""
+    configured = get_env_any("MARIS_HF_FALLBACK_CACHE_DIR")
+    fallback_dir = (Path(tempfile.gettempdir()) / "maris-hf-cache").resolve()
+    candidate = Path(configured).expanduser() if configured else fallback_dir
+
+    try:
+        resolved = candidate.resolve(strict=False)
+        if resolved == Path(resolved.anchor):
+            raise ValueError(f"nedroša cache direktorija: {resolved}")
+        if resolved.exists() and not resolved.is_dir():
+            raise ValueError(f"cache ceļš nav direktorija: {resolved}")
+        resolved.mkdir(parents=True, exist_ok=True)
+        return str(resolved)
+    except (OSError, ValueError) as exc:
+        if configured:
+            logger.warning(
+                "Ignorējam nederīgu MARIS_HF_FALLBACK_CACHE_DIR=%s: %s; lietojam %s.",
+                configured,
+                exc,
+                fallback_dir,
+            )
+        fallback_dir.mkdir(parents=True, exist_ok=True)
+        return str(fallback_dir)
+
+
+def _call_with_hf_cache_recovery(
+    action: str,
+    call: Callable[..., Any],
+    *args: Any,
+    recovery_cache_dir: str | None = None,
+    **kwargs: Any,
+) -> tuple[Any, str | None]:
+    """Izsauc HF funkciju un pie cache lock I/O kļūdas pārslēdzas uz fallback cache."""
+    call_kwargs = dict(kwargs)
+    if recovery_cache_dir is not None:
+        call_kwargs["cache_dir"] = recovery_cache_dir
+        return call(*args, **call_kwargs), recovery_cache_dir
+
+    try:
+        return call(*args, **call_kwargs), None
+    except Exception as exc:  # noqa: BLE001
+        if not _is_hf_cache_lock_io_error(exc):
+            raise
+
+        recovery_cache_dir = _resolve_hf_cache_recovery_dir()
+        logger.warning(
+            "Hugging Face cache lock kļūda (%s); atkārtojam ar fallback cache %s.",
+            action,
+            recovery_cache_dir,
+        )
+        call_kwargs["cache_dir"] = recovery_cache_dir
+        return call(*args, **call_kwargs), recovery_cache_dir
+
+
+def _preview_discovered_files(discovered_files: list[str]) -> str:
+    """Atgriež īsu atrasto failu sarakstu kļūdu ziņojumiem."""
+    if not discovered_files:
+        return "nav"
+    return ", ".join(sorted(discovered_files)[:5])
+
+
+def _preview_data_files(data_files: list[str]) -> str:
+    """Atgriež īsu datu failu sarakstu kļūdu ziņojumiem."""
+    preview_paths: list[str] = []
+    for file_name in sorted(data_files)[:5]:
+        file_path = Path(file_name)
+        if "data" in file_path.parts:
+            data_index = file_path.parts.index("data")
+            preview_paths.append("/".join(file_path.parts[data_index:]))
+            continue
+        preview_paths.append(file_path.name)
+    return ", ".join(preview_paths) if preview_paths else "nav"
+
+
+def _summarize_exception_messages(exc: Exception) -> str:
+    """Savāc īsu izņēmumu ķēdes kopsavilkumu lietotājam."""
+    details: list[str] = []
+    for current in _iter_exception_chain(exc):
+        message = str(current).strip()
+        if not message or message in details:
+            continue
+        details.append(message)
+    return " | ".join(details[:3]) if details else exc.__class__.__name__
+
+
+def _build_empty_repo_message(
+    repo_id: str,
+    snapshot_dir: Path,
+    discovered_files: list[str],
+) -> str:
+    """Izveido precīzu kļūdas ziņojumu tukšam atmiņas repozitorijam."""
+    preview = _preview_discovered_files(discovered_files)
+    return (
+        f"Maris atmiņas repo {repo_id} pašlaik nesatur nevienu atbalstītu datu failu "
+        f"(.jsonl, .json, .csv, .parquet). Snapshot direktorijā {snapshot_dir} tika "
+        f"atrasti tikai: {preview}. Lai salabotu origin repozitorijā, augšupielādē vismaz "
+        "vienu datu failu zem data/<type>/, piemēram "
+        "data/conversation/bootstrap.jsonl, un tad palaid apmācību vēlreiz. Ja lieto "
+        "Git LFS, pārliecinies, ka repozitorijā ir pats datu fails, nevis tikai "
+        ".gitattributes ieraksts."
+    )
+
+
+def _build_incomplete_snapshot_message(
+    repo_id: str,
+    snapshot_dir: Path,
+    discovered_files: list[str],
+    repo_data_files: list[str],
+) -> str:
+    """Izveido kļūdas ziņojumu, ja repo ir faili, bet snapshot tos nesatur."""
+    preview = _preview_discovered_files(discovered_files)
+    repo_preview = ", ".join(repo_data_files[:5])
+    return (
+        f"Maris atmiņas repo {repo_id} satur atbalstītus datu failus ({repo_preview}), bet "
+        f"snapshot direktorijā {snapshot_dir} tie netika atrasti. Snapshotā redzami: "
+        f"{preview}. Ja dataset repozitorijs glabā datus ar Git LFS, pārliecinieties, ka "
+        "tie ir pilnībā lejupielādēti un pieejami origin repozitorijā."
+    )
+
+
+def _build_invalid_data_files_message(
+    repo_id: str,
+    data_files: list[str],
+    exc: Exception,
+) -> str:
+    """Izveido kļūdas ziņojumu bojātiem vai nederīgiem datu failiem."""
+    preview = _preview_data_files(data_files)
+    details = _summarize_exception_messages(exc)
+    return (
+        f"Maris atmiņas repo {repo_id} datu failus neizdevās nolasīt apmācībai ({preview}). "
+        f"Cēlonis: {details}. Pārbaudi, vai faili ir pilnībā augšupielādēti, UTF-8 kodējumā "
+        "un satur derīgus JSON/JSONL, CSV vai Parquet ierakstus."
+    )
+
+
+def _find_snapshot_data_files(snapshot_dir: Path) -> tuple[str, list[str]]:
+    """Atrod ielādējamus datu failus dataset snapshot direktorijā."""
+    snapshot_dir = _validate_snapshot_dir(snapshot_dir)
+    search_roots = [snapshot_dir / "data", snapshot_dir]
+    discovered_files: list[str] = []
+
+    for root in search_roots:
+        if not root.exists():
+            continue
+
+        files_by_format: dict[str, list[str]] = {}
+        for file_path in _iter_snapshot_files(root):
+            discovered_files.append(str(file_path.relative_to(snapshot_dir)))
+            dataset_format = _SUPPORTED_DATASET_FORMATS.get(file_path.suffix.lower())
+            if dataset_format is None:
+                continue
+
+            files_by_format.setdefault(dataset_format, []).append(str(file_path))
+
+        if not files_by_format:
+            continue
+
+        if len(files_by_format) > 1:
+            formats = ", ".join(sorted(files_by_format))
+            raise ValueError(
+                f"Snapshot satur vairākus atbalstītus datu formātus vienlaikus: {formats}"
+            )
+
+        dataset_format, files = next(iter(files_by_format.items()))
+        return dataset_format, files
+
+    if discovered_files:
+        preview = _preview_discovered_files(discovered_files)
+        raise HFDatasetError(
+            "Dataset snapshot direktorijā nav atrasti atbalstīti dati: "
+            f"{snapshot_dir}. Atrastie faili: {preview}. "
+            "Ja dataset repozitorijs glabā datus ar Git LFS, pārliecinieties, ka "
+            "tie ir pilnībā lejupielādēti.",
+            discovered_files=discovered_files,
+        )
+
+    raise HFDatasetError(
+        f"Dataset snapshot direktorijā nav atrasti atbalstīti dati: {snapshot_dir}"
+    )
+
+
+def _validate_snapshot_dir(snapshot_dir: Path) -> Path:
+    """Normalizē un pārbauda snapshot direktoriju pirms rekursīvas skenēšanas."""
+    resolved = snapshot_dir.expanduser().resolve()
+    if not resolved.exists() or not resolved.is_dir():
+        raise HFDatasetError(f"Dataset snapshot direktorija nav derīga: {resolved}")
+    if resolved == Path(resolved.anchor):
+        raise HFDatasetError(
+            f"Dataset snapshot direktorija nav droša rekursīvai skenēšanai: {resolved}"
+        )
+    return resolved
+
+
+def _is_invalid_snapshot_dir_error(exc: HFDatasetError) -> bool:
+    """Nosaka, vai snapshot fallback atgrieza nederīgu vai bīstamu ceļu."""
+    message = str(exc)
+    return "nav derīga" in message or "nav droša rekursīvai skenēšanai" in message
+
+
+def _iter_snapshot_files(root: Path) -> Iterator[Path]:
+    """Iterē snapshot failus, izlaižot nederīgus sistēmas mezglus un OSError ceļus."""
+
+    def handle_walk_error(exc: OSError) -> None:
+        logger.warning(
+            "Skipping unreadable dataset snapshot path %s: %s",
+            getattr(exc, "filename", root),
+            exc,
+        )
+
+    for current_root, dirnames, filenames in os.walk(
+        root,
+        topdown=True,
+        onerror=handle_walk_error,
+        followlinks=False,
+    ):
+        dirnames.sort()
+        for filename in sorted(filenames):
+            candidate = Path(current_root) / filename
+            try:
+                if candidate.is_file():
+                    yield candidate
+            except OSError as exc:
+                logger.warning("Skipping unreadable dataset snapshot file %s: %s", candidate, exc)
+
+
+def _list_repo_data_files(repo_id: str, token: str | None) -> list[str]:
+    """Atrod atbalstītos datu failus tieši atmiņas repozitorijā."""
+    from huggingface_hub import HfApi  # type: ignore
+
+    api = HfApi(token=token)
+    repo_files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")
+    return sorted(
+        path
+        for path in repo_files
+        if _SUPPORTED_DATASET_FORMATS.get(Path(path).suffix.lower()) is not None
+    )
+
+
+def _coerce_training_record(record: Any) -> dict[str, Any]:
+    """Normalizē vienu ierakstu uz stabilu text-only formu apmācības datasetam."""
+    if isinstance(record, dict):
+        return {"text": record_to_training_text(record)}
+
+    try:
+        serialized = json.dumps(record, ensure_ascii=False, sort_keys=True)
+    except TypeError:
+        serialized = str(record)
+    return {"text": serialized}
+
+
+def _build_train_dataset(record_factory: Callable[[], Iterator[dict[str, Any]]]) -> Any:
+    """Izveido train split datasetu no ierakstu ģeneratora."""
+    from datasets import Dataset, DatasetDict  # type: ignore
+
+    return DatasetDict({"train": Dataset.from_generator(record_factory)})
+
+
+def _iter_dataset_splits(dataset: Any) -> Iterator[tuple[str, Any]]:
+    """Atgriež pieejamos dataset splitus neatkarīgi no konkrētā tipa."""
+    if isinstance(dataset, dict):
+        yield from dataset.items()
+        return
+
+    items = getattr(dataset, "items", None)
+    if callable(items):
+        yield from items()
+        return
+
+    keys = getattr(dataset, "keys", None)
+    if callable(keys):
+        for key in keys():
+            yield key, dataset[key]
+
+
+def _normalize_training_dataset(dataset: Any, repo_id: str) -> Any:
+    """Pārveido multi-split datasetu uz train split apmācībai."""
+    split_items = list(_iter_dataset_splits(dataset))
+    if not split_items or any(name == "train" for name, _ in split_items):
+        return dataset
+
+    logger.warning(
+        "Maris atmiņas repo %s atgrieza splitus bez 'train'; apvienojam tos vienā train split apmācībai.",
+        repo_id,
+    )
+
+    def iter_records() -> Iterator[dict[str, Any]]:
+        for _, split in split_items:
+            for record in split:
+                yield _coerce_training_record(record)
+
+    return _build_train_dataset(iter_records)
+
+
+def _iter_json_payload_records(payload: Any) -> Iterator[dict[str, Any]]:
+    """Izvērš JSON payload uz ierakstu plūsmu."""
+    if isinstance(payload, list):
+        for item in payload:
+            yield _coerce_training_record(item)
+        return
+
+    yield _coerce_training_record(payload)
+
+
+def _iter_json_file_records(data_files: list[str]) -> Iterator[dict[str, Any]]:
+    """Nolasa JSON/JSONL failus bez stingras nested-object shēmas."""
+    for file_name in data_files:
+        file_path = Path(file_name)
+        suffix = file_path.suffix.lower()
+        if suffix == ".jsonl":
+            with file_path.open(encoding="utf-8") as handle:
+                for line in handle:
+                    stripped = line.strip()
+                    if not stripped:
+                        continue
+                    yield _coerce_training_record(json.loads(stripped))
+            continue
+
+        if suffix == ".json":
+            payload = json.loads(file_path.read_text(encoding="utf-8"))
+            yield from _iter_json_payload_records(payload)
+            continue
+
+        raise ValueError(f"Neatbalstīts JSON datu fails: {file_path}")
+
+
+def _load_data_files_as_training_dataset(
+    repo_id: str,
+    dataset_format: str,
+    data_files: list[str],
+    *,
+    recovery_cache_dir: str | None = None,
+) -> Any:
+    """Ielādē atrastos datu failus apmācībai kā train split."""
+    try:
+        if dataset_format == "json":
+            return _build_train_dataset(lambda: _iter_json_file_records(data_files))
+
+        from datasets import load_dataset  # type: ignore
+
+        dataset, _ = _call_with_hf_cache_recovery(
+            f"load_dataset({dataset_format})",
+            load_dataset,
+            dataset_format,
+            data_files={"train": data_files},
+            recovery_cache_dir=recovery_cache_dir,
+        )
+        return dataset
+    except Exception as exc:  # noqa: BLE001
+        raise HFDatasetError(_build_invalid_data_files_message(repo_id, data_files, exc)) from exc
+
+
+def load_hf_dataset(repo_id: str | None = None) -> Any:
+    """Ielādē Maris atmiņas datasets."""
+    repo_id = repo_id or get_env_any_or_default(
+        "MARIS_MEMORY_REPO",
+        "MARIS_DATASET_REPO",
+        "HF_DATASET_REPO",
+        default="MarisUK/maris-ai-memory",
+    )
+    token = get_env_any("MARIS_REPO_TOKEN", "MARIS_TOKEN", "HF_TOKEN")
+    recovery_cache_dir: str | None = None
+
+    try:
+        from datasets import load_dataset  # type: ignore
+
+        logger.info("Ielādē dataset: %s", repo_id)
+        dataset, recovery_cache_dir = _call_with_hf_cache_recovery(
+            f"load_dataset({repo_id})",
+            load_dataset,
+            repo_id,
+            token=token,
+            recovery_cache_dir=recovery_cache_dir,
+        )
+        return _normalize_training_dataset(dataset, repo_id)
+    except Exception as exc:  # noqa: BLE001
+        if not _should_fallback_to_snapshot(exc):
+            logger.error("Dataseta ielādes kļūda: %s", exc)
+            raise
+
+        try:
+            from huggingface_hub import snapshot_download  # type: ignore
+
+            logger.warning(
+                "Maris atmiņas repo %s nevarēja ielādēt tieši; mēģinām apmācības snapshot fallback.",
+                repo_id,
+            )
+            snapshot_dir_str, recovery_cache_dir = _call_with_hf_cache_recovery(
+                f"snapshot_download({repo_id})",
+                snapshot_download,
+                repo_id=repo_id,
+                repo_type="dataset",
+                token=token,
+                recovery_cache_dir=recovery_cache_dir,
+            )
+            snapshot_dir = Path(snapshot_dir_str)
+            try:
+                dataset_format, data_files = _find_snapshot_data_files(snapshot_dir)
+            except HFDatasetError as missing_exc:
+                if _is_invalid_snapshot_dir_error(missing_exc):
+                    raise
+                repo_data_files = _list_repo_data_files(repo_id, token)
+                if not repo_data_files:
+                    raise HFDatasetError(
+                        _build_empty_repo_message(
+                            repo_id,
+                            snapshot_dir,
+                            missing_exc.discovered_files,
+                        ),
+                        discovered_files=missing_exc.discovered_files,
+                    ) from missing_exc
+
+                logger.warning(
+                    "Snapshot cache nesatur dataset failus; lejupielādējam atrastos data failus tieši: %s",
+                    ", ".join(repo_data_files[:5]),
+                )
+                snapshot_dir_str, recovery_cache_dir = _call_with_hf_cache_recovery(
+                    f"snapshot_download({repo_id}, allow_patterns)",
+                    snapshot_download,
+                    repo_id=repo_id,
+                    repo_type="dataset",
+                    token=token,
+                    allow_patterns=repo_data_files,
+                    recovery_cache_dir=recovery_cache_dir,
+                )
+                snapshot_dir = Path(snapshot_dir_str)
+                try:
+                    dataset_format, data_files = _find_snapshot_data_files(snapshot_dir)
+                except HFDatasetError as final_exc:
+                    raise HFDatasetError(
+                        _build_incomplete_snapshot_message(
+                            repo_id,
+                            snapshot_dir,
+                            final_exc.discovered_files,
+                            repo_data_files,
+                        ),
+                        discovered_files=final_exc.discovered_files,
+                    ) from final_exc
+            return _load_data_files_as_training_dataset(
+                repo_id,
+                dataset_format,
+                data_files,
+                recovery_cache_dir=recovery_cache_dir,
+            )
+        except Exception as fallback_exc:  # noqa: BLE001
+            logger.error("Dataseta ielādes kļūda: %s", fallback_exc)
+            raise

core-python/maris_core/data/preprocessing.py

@@ -0,0 +1,104 @@
+"""Datu priekšapstrāde."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+
+def clean_text(text: str) -> str:
+    """Notīra tekstu no nevēlamiem simboliem."""
+    text = re.sub(r"\s+", " ", text)
+    text = text.strip()
+    return text
+
+
+def truncate(text: str, max_chars: int = 4096) -> str:
+    """Apgriež tekstu līdz max_chars."""
+    return text[:max_chars]
+
+
+def format_conversation(messages: list[dict[str, str]]) -> str:
+    """Formatē sarunu kā vienu tekstu apmācībai."""
+    parts = []
+    for msg in messages:
+        role = msg.get("role", "user")
+        content = msg.get("content", "")
+        parts.append(f"<|{role}|>\n{content}\n<|end|>")
+    return "\n".join(parts)
+
+
+def _preserve_block_text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _append_section(lines: list[str], title: str, value: Any) -> None:
+    if value is None:
+        return
+    if isinstance(value, str):
+        text = _preserve_block_text(value)
+        if text:
+            lines.append(f"{title}:\n{text}")
+        return
+    if isinstance(value, list):
+        items = [_preserve_block_text(item) for item in value if _preserve_block_text(item)]
+        if items:
+            lines.append(f"{title}:\n" + "\n".join(f"- {item}" for item in items))
+        return
+    if isinstance(value, dict) and value:
+        lines.append(f"{title}:\n{json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True)}")
+
+
+def _format_structured_prompt_record(record: dict[str, Any]) -> str:
+    prompt = clean_text(str(record.get("prompt", "")))
+    user_sections = [prompt]
+    section_fields = (
+        ("Repo konteksts", record.get("repo_context")),
+        ("Mērķa fails", record.get("target_file")),
+        ("Esošais vai kļūdainais kods", record.get("buggy_code")),
+        ("Refactor vai diff konteksts", record.get("diff")),
+        ("Papildu konteksts", record.get("context")),
+        ("Pieņemšanas kritēriji", record.get("acceptance_criteria")),
+        ("Testi", record.get("tests")),
+        ("Robežgadījumi", record.get("edge_cases")),
+    )
+    for title, value in section_fields:
+        _append_section(user_sections, title, value)
+    metadata = record.get("metadata")
+    if metadata:
+        _append_section(user_sections, "Metadata", metadata)
+
+    messages = [
+        {"role": "user", "content": "\n\n".join(section for section in user_sections if section)}
+    ]
+    completion = _preserve_block_text(record.get("completion"))
+    if completion:
+        messages.append({"role": "assistant", "content": completion})
+    elif metadata:
+        messages.append(
+            {
+                "role": "assistant",
+                "content": json.dumps(metadata, ensure_ascii=False, sort_keys=True),
+            }
+        )
+    return format_conversation(messages)
+
+
+def record_to_training_text(record: dict[str, Any], max_chars: int = 4096) -> str:
+    """Pārveido vienu HF dataset ierakstu uz tekstu kauzālai apmācībai."""
+    if "text" in record and isinstance(record["text"], str):
+        return truncate(clean_text(record["text"]), max_chars=max_chars)
+
+    if "user" in record or "assistant" in record:
+        messages = [
+            {"role": "user", "content": clean_text(str(record.get("user", "")))},
+            {"role": "assistant", "content": clean_text(str(record.get("assistant", "")))},
+        ]
+        return truncate(format_conversation(messages), max_chars=max_chars)
+
+    if "prompt" in record:
+        return truncate(_format_structured_prompt_record(record), max_chars=max_chars)
+
+    serialized = json.dumps(record, ensure_ascii=False, sort_keys=True)
+    return truncate(clean_text(serialized), max_chars=max_chars)

core-python/maris_core/data/quality.py

@@ -0,0 +1,312 @@
+"""Dataset quality gate un dedupe helperi apmācībai."""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from dataclasses import asdict, dataclass, field
+from difflib import SequenceMatcher
+from typing import Any
+
+from maris_core.data.preprocessing import clean_text, record_to_training_text
+
+_PLACEHOLDER_TEXTS = {
+    "n/a",
+    "na",
+    "none",
+    "null",
+    "placeholder",
+    "test",
+    "todo",
+    "tbd",
+}
+_WORD_RE = re.compile(r"\w+", re.UNICODE)
+_REPEATED_SEGMENT_SPLIT_RE = re.compile(r"(?:\n+|(?<=[.!?])\s+)")
+_MIN_REPEATED_SEGMENT_LENGTH = 8
+
+
+@dataclass(slots=True, frozen=True)
+class DatasetQualityGateConfig:
+    """Konfigurācija training kvalitātes vārtiem."""
+
+    enabled: bool = True
+    dedupe_enabled: bool = True
+    min_text_chars: int = 4
+    max_text_chars: int = 8192
+    min_unique_char_ratio: float = 0.2
+    min_completion_chars: int = 12
+    max_prompt_echo_similarity: float = 0.92
+    max_repeated_line_fraction: float = 0.34
+
+
+@dataclass(slots=True)
+class DatasetQualitySplitReport:
+    """Viena split kvalitātes kopsavilkums."""
+
+    split_name: str
+    input_records: int = 0
+    kept_records: int = 0
+    dropped_records: int = 0
+    duplicates_removed: int = 0
+    reasons: dict[str, int] = field(default_factory=dict)
+    sample_rejections: list[dict[str, str]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class DatasetQualityReport:
+    """Pilns dataset quality gate artefakts."""
+
+    artifact_type: str
+    config: dict[str, Any]
+    splits: dict[str, DatasetQualitySplitReport]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "artifact_type": self.artifact_type,
+            "config": self.config,
+            "splits": {name: report.to_dict() for name, report in self.splits.items()},
+            "input_records": sum(report.input_records for report in self.splits.values()),
+            "kept_records": sum(report.kept_records for report in self.splits.values()),
+            "dropped_records": sum(report.dropped_records for report in self.splits.values()),
+            "duplicates_removed": sum(report.duplicates_removed for report in self.splits.values()),
+        }
+
+
+def apply_quality_gate_to_records(
+    records: list[dict[str, Any]],
+    *,
+    split_name: str,
+    config: DatasetQualityGateConfig,
+) -> tuple[list[dict[str, Any]], DatasetQualitySplitReport]:
+    """Filtrē ierakstus un noņem dublikātus pirms treniņa."""
+
+    if not config.enabled:
+        report = DatasetQualitySplitReport(
+            split_name=split_name,
+            input_records=len(records),
+            kept_records=len(records),
+        )
+        return [_normalize_record(record) for record in records], report
+
+    report = DatasetQualitySplitReport(split_name=split_name)
+    kept_records: list[dict[str, Any]] = []
+    seen_signatures: set[str] = set()
+
+    for raw_record in records:
+        report.input_records += 1
+        record = _normalize_record(raw_record)
+        training_text = record_to_training_text(record, max_chars=config.max_text_chars)
+        rejection_reason = _get_rejection_reason(training_text, record, config)
+        if rejection_reason is not None:
+            _record_rejection(report, rejection_reason, training_text)
+            continue
+
+        signature = _training_text_signature(training_text)
+        if config.dedupe_enabled and signature in seen_signatures:
+            report.duplicates_removed += 1
+            _record_rejection(report, "duplicate_training_text", training_text)
+            continue
+
+        seen_signatures.add(signature)
+        kept_records.append(record)
+        report.kept_records += 1
+
+    report.dropped_records = report.input_records - report.kept_records
+    return kept_records, report
+
+
+def build_dataset_quality_report(
+    *,
+    config: DatasetQualityGateConfig,
+    train_report: DatasetQualitySplitReport,
+    eval_report: DatasetQualitySplitReport | None = None,
+) -> DatasetQualityReport:
+    """Izveido serializējamu kvalitātes artefaktu."""
+
+    splits = {train_report.split_name: train_report}
+    if eval_report is not None:
+        splits[eval_report.split_name] = eval_report
+    return DatasetQualityReport(
+        artifact_type="dataset-quality-report",
+        config=asdict(config),
+        splits=splits,
+    )
+
+
+def _normalize_record(record: dict[str, Any]) -> dict[str, Any]:
+    normalized: dict[str, Any] = {}
+    for key, value in record.items():
+        normalized[key] = _normalize_value(value)
+    return normalized
+
+
+def _normalize_value(value: Any) -> Any:
+    if isinstance(value, str):
+        return clean_text(value)
+    if isinstance(value, dict):
+        return {str(key): _normalize_value(item) for key, item in value.items()}
+    if isinstance(value, list):
+        return [_normalize_value(item) for item in value]
+    return value
+
+
+def _get_rejection_reason(
+    training_text: str,
+    record: dict[str, Any],
+    config: DatasetQualityGateConfig,
+) -> str | None:
+    normalized_text = clean_text(training_text)
+    if not normalized_text:
+        return "empty_training_text"
+    if len(normalized_text) < config.min_text_chars:
+        return "too_short"
+    if len(normalized_text) > config.max_text_chars:
+        return "too_long"
+
+    if normalized_text.casefold() in _PLACEHOLDER_TEXTS:
+        return "placeholder_text"
+
+    if _has_repeated_line_noise(normalized_text, config.max_repeated_line_fraction):
+        return "repeated_line_noise"
+
+    if _looks_repetitive(normalized_text, config.min_unique_char_ratio):
+        return "low_information_density"
+
+    conversation_rejection = _conversation_rejection_reason(record, config)
+    if conversation_rejection is not None:
+        return conversation_rejection
+
+    return None
+
+
+def _looks_repetitive(value: str, min_unique_char_ratio: float) -> bool:
+    compact = "".join(character for character in value.casefold() if not character.isspace())
+    if not compact:
+        return True
+    unique_ratio = len(set(compact)) / len(compact)
+    if unique_ratio >= min_unique_char_ratio:
+        return False
+
+    words = _WORD_RE.findall(value.casefold())
+    if len(words) >= 6:
+        # Garākiem strukturētiem promptiem simbolu dažādība var būt zema marķējuma/JSON dēļ,
+        # tāpēc izmantojam arī vārdu dažādību, lai neatmestu jēgpilnus ierakstus.
+        unique_word_ratio = len(set(words)) / len(words)
+        if unique_word_ratio >= 0.45:
+            return False
+
+    return True
+
+
+def _conversation_rejection_reason(
+    record: dict[str, Any],
+    config: DatasetQualityGateConfig,
+) -> str | None:
+    prompt, completion = _conversation_pair(record)
+    if prompt is None or completion is None:
+        return None
+    if not prompt or not completion:
+        return "invalid_conversation_pair"
+    if prompt.casefold() == completion.casefold():
+        return "invalid_conversation_pair"
+    if completion.casefold() in _PLACEHOLDER_TEXTS:
+        return "placeholder_response"
+    if len(completion) < config.min_completion_chars and len(prompt) >= config.min_completion_chars:
+        return "response_too_short"
+    if _looks_like_prompt_echo(
+        prompt,
+        completion,
+        max_prompt_echo_similarity=config.max_prompt_echo_similarity,
+    ):
+        return "prompt_echo_response"
+    return None
+
+
+def _conversation_pair(record: dict[str, Any]) -> tuple[str | None, str | None]:
+    prompt = _coerce_quality_text(
+        record.get("user"),
+        record.get("prompt"),
+        record.get("instruction"),
+        record.get("input"),
+    )
+    completion = _coerce_quality_text(
+        record.get("assistant"),
+        record.get("completion"),
+        record.get("response"),
+        record.get("output"),
+    )
+    return prompt, completion
+
+
+def _coerce_quality_text(*values: Any) -> str | None:
+    for value in values:
+        if isinstance(value, str):
+            normalized = clean_text(value)
+            if normalized:
+                return normalized
+    return None
+
+
+def _looks_like_prompt_echo(
+    prompt: str,
+    completion: str,
+    *,
+    max_prompt_echo_similarity: float,
+) -> bool:
+    prompt_normalized = prompt.casefold()
+    completion_normalized = completion.casefold()
+    if prompt_normalized == completion_normalized:
+        return True
+    if (
+        (
+            completion_normalized.startswith(prompt_normalized)
+            or prompt_normalized.startswith(completion_normalized)
+        )
+        and len(completion_normalized) <= int(len(prompt_normalized) * 1.2)
+    ):
+        return True
+    prompt_tokens = prompt_normalized.split()
+    completion_tokens = completion_normalized.split()
+    if not prompt_tokens or not completion_tokens:
+        return False
+    shared_tokens = len(set(prompt_tokens) & set(completion_tokens))
+    completion_overlap = shared_tokens / max(len(set(completion_tokens)), 1)
+    if completion_overlap < 0.8:
+        return False
+    similarity = SequenceMatcher(a=prompt_normalized, b=completion_normalized).ratio()
+    return (
+        similarity >= max_prompt_echo_similarity
+        and len(completion_normalized) <= int(len(prompt_normalized) * 1.2)
+    )
+
+
+def _has_repeated_line_noise(value: str, max_repeated_line_fraction: float) -> bool:
+    lines = [line.strip().casefold() for line in _REPEATED_SEGMENT_SPLIT_RE.split(value) if line.strip()]
+    if len(lines) < 3:
+        return False
+    repeated_counts = Counter(line for line in lines if len(line) >= _MIN_REPEATED_SEGMENT_LENGTH)
+    if not repeated_counts:
+        return False
+    return max(repeated_counts.values()) / len(lines) > max_repeated_line_fraction
+
+
+def _training_text_signature(value: str) -> str:
+    return " ".join(value.casefold().split())
+
+
+def _record_rejection(
+    report: DatasetQualitySplitReport,
+    reason: str,
+    training_text: str,
+) -> None:
+    report.reasons[reason] = report.reasons.get(reason, 0) + 1
+    if len(report.sample_rejections) < 5:
+        report.sample_rejections.append(
+            {
+                "reason": reason,
+                "preview": training_text[:160],
+            }
+        )

core-python/maris_core/data/scoring.py

@@ -0,0 +1,597 @@
+"""Dataseta scoring, source-aware weighting un benchmark feedback palīgi."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from maris_core.data.preprocessing import clean_text, record_to_training_text
+
+DEFAULT_SOURCE_WEIGHT_MAP = {
+    "production": 1.3,
+    "synthetic": 1.0,
+    "noisy": 0.65,
+    "unknown": 1.0,
+}
+SOURCE_TIER_TOKEN_MAP = {
+    "production": ("production", "prod", "live", "human", "curated", "real", "customer"),
+    "synthetic": ("synthetic", "generated", "augmented", "distilled", "bootstrap", "seeded"),
+    "noisy": ("noisy", "weak", "scraped", "raw", "unfiltered", "test"),
+}
+BENCHMARK_METRIC_ALIASES = {
+    "reasoning": {"reasoning", "analysis", "logic", "planner"},
+    "coding": {"coding", "code", "programming", "developer"},
+    "long_context": {"long_context", "context", "memory", "retrieval"},
+    "helpfulness": {"helpfulness", "helpful", "assistant", "support"},
+    "factuality": {"factuality", "facts", "grounding", "grounded"},
+    "latvian_quality": {"latvian_quality", "latvian", "language_lv", "lv"},
+    "safety": {"safety", "safe", "guardrails", "policy"},
+}
+
+
+@dataclass(slots=True, frozen=True)
+class DatasetScoringConfig:
+    """Konfigurācija dataset scoring/weighting solim."""
+
+    enabled: bool = True
+    weighted_repetition_enabled: bool = True
+    max_text_chars: int = 8192
+    low_score_repeat_count: int = 1
+    medium_score_repeat_count: int = 2
+    high_score_repeat_count: int = 3
+    medium_score_threshold: float = 0.55
+    high_score_threshold: float = 0.8
+    source_weighting_enabled: bool = True
+    source_weight_map: dict[str, float] = field(
+        default_factory=lambda: DEFAULT_SOURCE_WEIGHT_MAP.copy()
+    )
+    category_weight_map: dict[str, float] = field(default_factory=dict)
+    max_effective_repeat_count: int = 6
+    benchmark_feedback_enabled: bool = True
+    benchmark_feedback_path: str = ""
+    benchmark_feedback_boost_scale: float = 2.0
+    benchmark_feedback_max_multiplier: float = 1.75
+
+
+@dataclass(slots=True, frozen=True)
+class DatasetBenchmarkFeedback:
+    """Iepriekšējā benchmark artefakta kopsavilkums reweighting vajadzībām."""
+
+    artifact_path: str
+    deficient_metrics: dict[str, dict[str, float]]
+    overall_multiplier: float = 1.0
+    discovery_mode: str = "explicit"
+
+
+@dataclass(slots=True)
+class DatasetScoringSplitReport:
+    """Viena split scoring rezultātu kopsavilkums."""
+
+    split_name: str
+    input_records: int = 0
+    expanded_records: int = 0
+    average_score: float = 0.0
+    max_score: float = 0.0
+    min_score: float = 0.0
+    repeated_records: int = 0
+    score_buckets: dict[str, int] = field(default_factory=dict)
+    repeat_buckets: dict[str, int] = field(default_factory=dict)
+    source_tiers: dict[str, int] = field(default_factory=dict)
+    category_buckets: dict[str, int] = field(default_factory=dict)
+    feedback_metric_hits: dict[str, int] = field(default_factory=dict)
+    feedback_boosted_records: int = 0
+    average_repeat_multiplier: float = 1.0
+    source_dashboard: dict[str, dict[str, float]] = field(default_factory=dict)
+    category_dashboard: dict[str, dict[str, float]] = field(default_factory=dict)
+    sample_scores: list[dict[str, Any]] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(slots=True)
+class DatasetScoringReport:
+    """Pilns dataset scoring artefakts."""
+
+    artifact_type: str
+    config: dict[str, Any]
+    splits: dict[str, DatasetScoringSplitReport]
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "artifact_type": self.artifact_type,
+            "config": self.config,
+            "splits": {name: report.to_dict() for name, report in self.splits.items()},
+            "input_records": sum(report.input_records for report in self.splits.values()),
+            "expanded_records": sum(report.expanded_records for report in self.splits.values()),
+            "repeated_records": sum(report.repeated_records for report in self.splits.values()),
+        }
+
+
+def apply_scoring_to_records(
+    records: list[dict[str, Any]],
+    *,
+    split_name: str,
+    config: DatasetScoringConfig,
+    expand_weights: bool,
+    benchmark_feedback: DatasetBenchmarkFeedback | None = None,
+) -> tuple[list[dict[str, Any]], DatasetScoringSplitReport]:
+    """Aprēķina score un materializē weighting kā atkārtojumus."""
+
+    report = DatasetScoringSplitReport(split_name=split_name, input_records=len(records))
+    if not records:
+        return [], report
+
+    scored_records: list[tuple[dict[str, Any], float, int]] = []
+    total_score = 0.0
+    total_repeat_multiplier = 0.0
+    source_dashboard: dict[str, dict[str, float]] = {}
+    category_dashboard: dict[str, dict[str, float]] = {}
+
+    for record in records:
+        score = score_record(record, max_text_chars=config.max_text_chars)
+        source_tier = detect_source_tier(record)
+        category_label = detect_record_category(record)
+        source_multiplier = _source_multiplier_for_record(record, config)
+        category_multiplier = _category_multiplier_for_record(record, config)
+        feedback_multiplier, matched_metrics = _feedback_multiplier_for_record(
+            record,
+            benchmark_feedback,
+        )
+        repeat_multiplier = source_multiplier * category_multiplier * feedback_multiplier
+        repeat_count = _effective_repeat_count(
+            score,
+            repeat_multiplier=repeat_multiplier,
+            config=config,
+            expand_weights=expand_weights,
+        )
+        total_score += score
+        total_repeat_multiplier += repeat_multiplier
+        report.score_buckets[_score_bucket(score)] = (
+            report.score_buckets.get(_score_bucket(score), 0) + 1
+        )
+        report.repeat_buckets[str(repeat_count)] = (
+            report.repeat_buckets.get(str(repeat_count), 0) + 1
+        )
+        report.source_tiers[source_tier] = report.source_tiers.get(source_tier, 0) + 1
+        report.category_buckets[category_label] = report.category_buckets.get(category_label, 0) + 1
+        if repeat_count > 1:
+            report.repeated_records += 1
+        if matched_metrics:
+            report.feedback_boosted_records += 1
+            for metric in matched_metrics:
+                report.feedback_metric_hits[metric] = report.feedback_metric_hits.get(metric, 0) + 1
+        _update_dashboard_bucket(
+            source_dashboard,
+            source_tier,
+            score=score,
+            repeat_count=repeat_count,
+            repeat_multiplier=repeat_multiplier,
+            boosted=bool(matched_metrics),
+        )
+        _update_dashboard_bucket(
+            category_dashboard,
+            category_label,
+            score=score,
+            repeat_count=repeat_count,
+            repeat_multiplier=repeat_multiplier,
+            boosted=bool(matched_metrics),
+        )
+        if len(report.sample_scores) < 5:
+            report.sample_scores.append(
+                {
+                    "score": round(score, 4),
+                    "source_tier": source_tier,
+                    "category": category_label,
+                    "source_multiplier": round(source_multiplier, 4),
+                    "category_multiplier": round(category_multiplier, 4),
+                    "feedback_multiplier": round(feedback_multiplier, 4),
+                    "matched_metrics": matched_metrics,
+                    "repeat_count": repeat_count,
+                    "preview": record_to_training_text(record, max_chars=config.max_text_chars)[
+                        :160
+                    ],
+                }
+            )
+        scored_records.append((record, score, repeat_count))
+
+    report.average_score = round(total_score / len(scored_records), 4)
+    report.average_repeat_multiplier = round(total_repeat_multiplier / len(scored_records), 4)
+    report.source_dashboard = _finalize_dashboard(source_dashboard)
+    report.category_dashboard = _finalize_dashboard(category_dashboard)
+    score_values = [score for _, score, _ in scored_records]
+    report.min_score = round(min(score_values), 4)
+    report.max_score = round(max(score_values), 4)
+
+    if not config.enabled:
+        expanded = list(records)
+    else:
+        expanded = []
+        for record, score, repeat_count in scored_records:
+            repeat_total = repeat_count if expand_weights else 1
+            for copy_index in range(repeat_total):
+                enriched = dict(record)
+                enriched["maris_dataset_score"] = round(score, 4)
+                enriched["maris_dataset_repeat_count"] = repeat_count
+                enriched["maris_dataset_repeat_index"] = copy_index
+                enriched["maris_dataset_source_tier"] = detect_source_tier(record)
+                expanded.append(enriched)
+
+    report.expanded_records = len(expanded)
+    return expanded, report
+
+
+def build_dataset_scoring_report(
+    *,
+    config: DatasetScoringConfig,
+    train_report: DatasetScoringSplitReport,
+    eval_report: DatasetScoringSplitReport | None = None,
+) -> DatasetScoringReport:
+    """Izveido serializējamu scoring artefaktu."""
+
+    splits = {train_report.split_name: train_report}
+    if eval_report is not None:
+        splits[eval_report.split_name] = eval_report
+    return DatasetScoringReport(
+        artifact_type="dataset-scoring-report",
+        config=asdict(config),
+        splits=splits,
+    )
+
+
+def load_benchmark_feedback(
+    path: str | Path,
+    *,
+    targets: dict[str, float],
+    boost_scale: float,
+    max_multiplier: float,
+) -> DatasetBenchmarkFeedback:
+    """Ielādē benchmark manifestu/feedback artefaktu un pārvērš reweighting noteikumos."""
+
+    payload = json.loads(Path(path).read_text(encoding="utf-8"))
+    if "deficient_metrics" in payload:
+        deficient_metrics = {
+            str(metric): {
+                "target": float(details.get("target", 0.0)),
+                "actual": float(details.get("actual", 0.0)),
+                "deficit": float(details.get("deficit", 0.0)),
+                "multiplier": float(details.get("multiplier", 1.0)),
+            }
+            for metric, details in payload.get("deficient_metrics", {}).items()
+            if isinstance(details, dict)
+        }
+        overall_multiplier = float(payload.get("overall_multiplier", 1.0) or 1.0)
+        return DatasetBenchmarkFeedback(
+            artifact_path=str(path),
+            deficient_metrics=deficient_metrics,
+            overall_multiplier=overall_multiplier,
+            discovery_mode=str(payload.get("discovery_mode", "explicit") or "explicit"),
+        )
+
+    score_manifest = payload.get("score_manifest")
+    if not isinstance(score_manifest, dict):
+        raise ValueError("Benchmark feedback failā jābūt `score_manifest` vai `deficient_metrics`.")
+
+    deficient_metrics: dict[str, dict[str, float]] = {}
+    overall_multiplier = 1.0
+    for metric, target in targets.items():
+        actual = float(score_manifest.get(metric, score_manifest.get("overall", 0.0)) or 0.0)
+        deficit = max(float(target) - actual, 0.0)
+        if deficit <= 0:
+            continue
+        multiplier = min(1.0 + deficit * boost_scale, max_multiplier)
+        deficient_metrics[str(metric)] = {
+            "target": float(target),
+            "actual": actual,
+            "deficit": round(deficit, 4),
+            "multiplier": round(multiplier, 4),
+        }
+        if metric == "overall":
+            overall_multiplier = round(multiplier, 4)
+
+    return DatasetBenchmarkFeedback(
+        artifact_path=str(path),
+        deficient_metrics=deficient_metrics,
+        overall_multiplier=overall_multiplier,
+    )
+
+
+def build_benchmark_feedback_artifact(
+    feedback: DatasetBenchmarkFeedback,
+) -> dict[str, Any]:
+    """Izveido serializējamu benchmark-feedback artefaktu."""
+
+    return {
+        "artifact_type": "benchmark-feedback-reweighting",
+        "artifact_path": feedback.artifact_path,
+        "overall_multiplier": feedback.overall_multiplier,
+        "discovery_mode": feedback.discovery_mode,
+        "deficient_metrics": feedback.deficient_metrics,
+    }
+
+
+def score_record(record: dict[str, Any], *, max_text_chars: int) -> float:
+    """Aprēķina heuristisku datu kvalitātes score [0,1] intervālā."""
+
+    text = clean_text(record_to_training_text(record, max_chars=max_text_chars))
+    if not text:
+        return 0.0
+
+    text_length = len(text)
+    tokens = [token for token in text.casefold().split() if token]
+    unique_tokens = len(set(tokens))
+
+    length_score = min(text_length / 240.0, 1.0)
+    diversity_score = min(unique_tokens / max(len(tokens), 1), 1.0)
+    structure_score = _structure_score(record)
+    metadata_score = _metadata_score(record)
+
+    score = (
+        0.35 * length_score
+        + 0.30 * diversity_score
+        + 0.20 * structure_score
+        + 0.15 * metadata_score
+    )
+    return max(0.0, min(round(score, 4), 1.0))
+
+
+def detect_source_tier(record: dict[str, Any]) -> str:
+    """Atrod source tier svarošnai."""
+
+    candidates = _record_terms(record)
+    explicit = record.get("source_tier") or record.get("source_quality")
+    if isinstance(explicit, str):
+        normalized = clean_text(explicit).casefold().replace(" ", "_")
+        if normalized in DEFAULT_SOURCE_WEIGHT_MAP:
+            return normalized
+
+    for tier, tokens in SOURCE_TIER_TOKEN_MAP.items():
+        if any(token in candidates for token in tokens):
+            return tier
+    return "unknown"
+
+
+def detect_record_category(record: dict[str, Any]) -> str:
+    """Atrod stabilu kategorijas label dashboard grupēšanai."""
+
+    for candidate in (
+        record.get("category"),
+        record.get("task_category"),
+        record.get("branch_focus"),
+    ):
+        if isinstance(candidate, str) and clean_text(candidate):
+            return _normalize_label(candidate)
+
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict):
+        for key in ("category", "focus", "type"):
+            candidate = metadata.get(key)
+            if isinstance(candidate, str) and clean_text(candidate):
+                return _normalize_label(candidate)
+    return "general"
+
+
+def _structure_score(record: dict[str, Any]) -> float:
+    if isinstance(record.get("user"), str) and isinstance(record.get("assistant"), str):
+        user = clean_text(str(record.get("user", "")))
+        assistant = clean_text(str(record.get("assistant", "")))
+        if user and assistant and user.casefold() != assistant.casefold():
+            return 1.0
+        return 0.3
+    if isinstance(record.get("prompt"), str):
+        return 0.8 if clean_text(str(record.get("prompt", ""))) else 0.2
+    if isinstance(record.get("text"), str):
+        return 0.6 if clean_text(str(record.get("text", ""))) else 0.2
+    return 0.4
+
+
+def _metadata_score(record: dict[str, Any]) -> float:
+    metadata = record.get("metadata")
+    score = 0.0
+    if isinstance(metadata, dict):
+        score += min(len(metadata) / 4.0, 1.0) * 0.7
+    if isinstance(record.get("language"), str) and clean_text(str(record["language"])):
+        score += 0.15
+    if isinstance(record.get("source"), str) and clean_text(str(record["source"])):
+        score += 0.15
+    return min(score, 1.0)
+
+
+def _source_multiplier_for_record(record: dict[str, Any], config: DatasetScoringConfig) -> float:
+    if not config.source_weighting_enabled:
+        return 1.0
+    source_tier = detect_source_tier(record)
+    return max(0.1, float(config.source_weight_map.get(source_tier, 1.0)))
+
+
+def _category_multiplier_for_record(record: dict[str, Any], config: DatasetScoringConfig) -> float:
+    if not config.category_weight_map:
+        return 1.0
+    labels = _record_labels(record)
+    matches = [
+        float(weight)
+        for label, weight in config.category_weight_map.items()
+        if clean_text(str(label)).casefold().replace("-", "_").replace(" ", "_") in labels
+    ]
+    if not matches:
+        return 1.0
+    return max(0.1, max(matches))
+
+
+def _feedback_multiplier_for_record(
+    record: dict[str, Any],
+    feedback: DatasetBenchmarkFeedback | None,
+) -> tuple[float, list[str]]:
+    if feedback is None or not feedback.deficient_metrics:
+        return 1.0, []
+
+    labels = _record_labels(record)
+    matched_metrics = sorted(
+        metric
+        for metric in feedback.deficient_metrics
+        if metric == "overall"
+        or labels.intersection(BENCHMARK_METRIC_ALIASES.get(metric, {metric}))
+    )
+    if not matched_metrics:
+        return feedback.overall_multiplier, ["overall"] if feedback.overall_multiplier > 1.0 else []
+
+    specific_multiplier = (
+        max(
+            float(feedback.deficient_metrics[metric].get("multiplier", 1.0) or 1.0)
+            for metric in matched_metrics
+            if metric != "overall"
+        )
+        if any(metric != "overall" for metric in matched_metrics)
+        else 1.0
+    )
+    combined = min(
+        max(1.0, specific_multiplier) * max(1.0, feedback.overall_multiplier),
+        max(
+            [feedback.overall_multiplier]
+            + [
+                float(details.get("multiplier", 1.0) or 1.0)
+                for details in feedback.deficient_metrics.values()
+            ]
+        ),
+    )
+    return round(max(1.0, combined), 4), matched_metrics
+
+
+def _effective_repeat_count(
+    score: float,
+    *,
+    repeat_multiplier: float,
+    config: DatasetScoringConfig,
+    expand_weights: bool,
+) -> int:
+    if not config.enabled or not expand_weights or not config.weighted_repetition_enabled:
+        return 1
+    base_repeat_count = _repeat_count_for_score(score, config)
+    weighted = int(round(base_repeat_count * max(repeat_multiplier, 0.1)))
+    return max(1, min(weighted, config.max_effective_repeat_count))
+
+
+def _repeat_count_for_score(score: float, config: DatasetScoringConfig) -> int:
+    if score >= config.high_score_threshold:
+        return max(1, config.high_score_repeat_count)
+    if score >= config.medium_score_threshold:
+        return max(1, config.medium_score_repeat_count)
+    return max(1, config.low_score_repeat_count)
+
+
+def _score_bucket(score: float) -> str:
+    if score >= 0.8:
+        return "high"
+    if score >= 0.55:
+        return "medium"
+    return "low"
+
+
+def _record_terms(record: dict[str, Any]) -> set[str]:
+    values: list[str] = []
+    for key in ("source", "source_type", "source_quality", "source_tier", "category", "language"):
+        value = record.get(key)
+        if isinstance(value, str):
+            values.extend(value.casefold().replace("-", " ").replace("_", " ").split())
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict):
+        for key in ("source", "source_type", "source_quality", "source_tier", "origin", "category"):
+            value = metadata.get(key)
+            if isinstance(value, str):
+                values.extend(value.casefold().replace("-", " ").replace("_", " ").split())
+        tags = metadata.get("tags")
+        if isinstance(tags, list):
+            for item in tags:
+                if isinstance(item, str):
+                    values.extend(item.casefold().replace("-", " ").replace("_", " ").split())
+    tags = record.get("tags")
+    if isinstance(tags, list):
+        for item in tags:
+            if isinstance(item, str):
+                values.extend(item.casefold().replace("-", " ").replace("_", " ").split())
+    return set(values)
+
+
+def _record_labels(record: dict[str, Any]) -> set[str]:
+    labels: set[str] = set()
+    for key in ("category", "branch_focus", "source", "language"):
+        value = record.get(key)
+        if isinstance(value, str) and clean_text(value):
+            normalized = clean_text(value).casefold().replace("-", "_").replace(" ", "_")
+            labels.add(normalized)
+            labels.update(normalized.split("_"))
+    metadata = record.get("metadata")
+    if isinstance(metadata, dict):
+        for key in ("category", "focus", "type", "language"):
+            value = metadata.get(key)
+            if isinstance(value, str) and clean_text(value):
+                normalized = clean_text(value).casefold().replace("-", "_").replace(" ", "_")
+                labels.add(normalized)
+                labels.update(normalized.split("_"))
+        tags = metadata.get("tags")
+        if isinstance(tags, list):
+            for item in tags:
+                if isinstance(item, str) and clean_text(item):
+                    normalized = clean_text(item).casefold().replace("-", "_").replace(" ", "_")
+                    labels.add(normalized)
+                    labels.update(normalized.split("_"))
+    tags = record.get("tags")
+    if isinstance(tags, list):
+        for item in tags:
+            if isinstance(item, str) and clean_text(item):
+                normalized = clean_text(item).casefold().replace("-", "_").replace(" ", "_")
+                labels.add(normalized)
+                labels.update(normalized.split("_"))
+    return labels
+
+
+def _update_dashboard_bucket(
+    dashboard: dict[str, dict[str, float]],
+    label: str,
+    *,
+    score: float,
+    repeat_count: int,
+    repeat_multiplier: float,
+    boosted: bool,
+) -> None:
+    """Uzkrāj dashboard metriku bucketam; `boosted` nozīmē benchmark feedback match."""
+
+    bucket = dashboard.setdefault(
+        label,
+        {
+            "records": 0.0,
+            "score_total": 0.0,
+            "repeat_total": 0.0,
+            "repeat_multiplier_total": 0.0,
+            "boosted_records": 0.0,
+        },
+    )
+    bucket["records"] += 1.0
+    bucket["score_total"] += score
+    bucket["repeat_total"] += float(repeat_count)
+    bucket["repeat_multiplier_total"] += repeat_multiplier
+    if boosted:
+        bucket["boosted_records"] += 1.0
+
+
+def _finalize_dashboard(dashboard: dict[str, dict[str, float]]) -> dict[str, dict[str, float]]:
+    finalized: dict[str, dict[str, float]] = {}
+    for label, bucket in sorted(dashboard.items()):
+        records = max(bucket.get("records", 0.0), 1.0)
+        finalized[label] = {
+            "records": int(bucket.get("records", 0.0)),
+            "average_score": round(bucket.get("score_total", 0.0) / records, 4),
+            "average_repeat_count": round(bucket.get("repeat_total", 0.0) / records, 4),
+            "average_repeat_multiplier": round(
+                bucket.get("repeat_multiplier_total", 0.0) / records,
+                4,
+            ),
+            "boosted_records": int(bucket.get("boosted_records", 0.0)),
+        }
+    return finalized
+
+
+def _normalize_label(value: str) -> str:
+    return clean_text(value).casefold().replace("-", "_").replace(" ", "_")

core-python/maris_core/data/validator.py

@@ -0,0 +1,268 @@
+"""Bootstrap dataset validācija."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+DATASET_TYPES = ("conversation", "code", "image", "music", "video", "autonomous")
+_PROMPT_TYPES = {"code", "image", "music", "video", "autonomous"}
+_COMMON_REQUIRED_STRING_FIELDS = ("timestamp", "type", "source")
+_CONVERSATION_REQUIRED_STRING_FIELDS = ("session_id", "user", "assistant", "language")
+_VALIDATION_PROFILES = {"auto", "bootstrap", "eval"}
+_EVAL_REQUIRED_STRING_FIELDS = (
+    "task_id",
+    "benchmark_version",
+    "suite",
+    "difficulty",
+    "evaluation_mode",
+    "risk_level",
+)
+_EVAL_REQUIRED_STRING_LIST_FIELDS = ("expected_behavior", "scoring_hints")
+_EVAL_REFERENCE_REQUIRED_CATEGORIES = {"conversation", "code"}
+
+
+class DatasetValidationError(ValueError):
+    """Bootstrap dataset satura validācijas kļūda."""
+
+    def __init__(self, issues: list[str]) -> None:
+        self.issues = issues
+        preview = "\n".join(f"- {issue}" for issue in issues[:20])
+        remaining = len(issues) - 20
+        if remaining > 0:
+            preview = f"{preview}\n- ... un vēl {remaining} problēmas"
+        super().__init__(f"Bootstrap dataset validācija neizdevās:\n{preview}")
+
+
+@dataclass(frozen=True)
+class DatasetValidationSummary:
+    """Bootstrap dataset validācijas kopsavilkums."""
+
+    dataset_dir: Path
+    files_checked: int
+    total_records: int
+    counts_by_category: dict[str, int]
+    duplicate_count: int
+
+
+def validate_dataset_dir(
+    dataset_dir: str | Path, *, profile: str = "auto"
+) -> DatasetValidationSummary:
+    """Validē lokālo bootstrap dataset direktoriju."""
+    root = Path(dataset_dir).expanduser().resolve()
+    issues: list[str] = []
+
+    resolved_profile = _resolve_profile(root, profile)
+
+    if not root.exists():
+        raise DatasetValidationError([f"Dataset direktorija nav atrasta: {root}"])
+    if not root.is_dir():
+        raise DatasetValidationError([f"Dataset ceļš nav direktorija: {root}"])
+
+    counts_by_category = {category: 0 for category in DATASET_TYPES}
+    duplicate_origins: dict[tuple[str, str], str] = {}
+    duplicate_count = 0
+    files_checked = 0
+
+    for file_path in sorted(root.rglob("*.jsonl")):
+        if any(part.startswith(".") for part in file_path.relative_to(root).parts):
+            continue
+        if "hf_cache" in file_path.parts:
+            continue
+
+        try:
+            relative_path = file_path.relative_to(root)
+        except ValueError:
+            relative_path = file_path
+
+        if len(relative_path.parts) < 2:
+            issues.append(f"{relative_path}: JSONL fails nav zem data tipa mapes.")
+            continue
+
+        category = relative_path.parts[0]
+        if category not in counts_by_category:
+            issues.append(
+                f"{relative_path}: neatbalstīta dataset kategorija '{category}'. "
+                f"Atļautās: {', '.join(DATASET_TYPES)}."
+            )
+            continue
+
+        files_checked += 1
+        with file_path.open(encoding="utf-8") as handle:
+            for line_number, raw_line in enumerate(handle, start=1):
+                stripped = raw_line.strip()
+                if not stripped:
+                    continue
+
+                location = f"{relative_path}:{line_number}"
+                try:
+                    record = json.loads(stripped)
+                except json.JSONDecodeError as exc:
+                    issues.append(f"{location}: nederīgs JSON ({exc.msg}).")
+                    continue
+
+                if not isinstance(record, dict):
+                    issues.append(f"{location}: ierakstam jābūt JSON objektam.")
+                    continue
+
+                counts_by_category[category] += 1
+                issues.extend(
+                    _validate_record(record, category, location, profile=resolved_profile)
+                )
+
+                signature = _record_signature(record, category)
+                if signature is None:
+                    continue
+                key = (category, signature)
+                first_location = duplicate_origins.get(key)
+                if first_location is None:
+                    duplicate_origins[key] = location
+                    continue
+                duplicate_count += 1
+                issues.append(
+                    f"{location}: dublikāts salīdzinājumā ar {first_location} "
+                    f"kategorijā '{category}'."
+                )
+
+    if files_checked == 0:
+        issues.append(f"{root}: nav atrasts neviens .jsonl bootstrap datu fails.")
+
+    if issues:
+        raise DatasetValidationError(issues)
+
+    return DatasetValidationSummary(
+        dataset_dir=root,
+        files_checked=files_checked,
+        total_records=sum(counts_by_category.values()),
+        counts_by_category=counts_by_category,
+        duplicate_count=duplicate_count,
+    )
+
+
+def format_summary(summary: DatasetValidationSummary) -> str:
+    """Atgriež īsu cilvēkam lasāmu validācijas kopsavilkumu."""
+    category_counts = ", ".join(
+        f"{category}={count}" for category, count in summary.counts_by_category.items()
+    )
+    return (
+        f"Dataset validācija veiksmīga: files={summary.files_checked}, "
+        f"records={summary.total_records}, duplicates={summary.duplicate_count}; "
+        f"{category_counts}"
+    )
+
+
+def _validate_record(
+    record: dict[str, Any], category: str, location: str, *, profile: str
+) -> list[str]:
+    issues: list[str] = []
+
+    for field_name in _COMMON_REQUIRED_STRING_FIELDS:
+        value = record.get(field_name)
+        if not _is_non_empty_string(value):
+            issues.append(f"{location}: trūkst ne-tukša lauka '{field_name}'.")
+
+    timestamp = record.get("timestamp")
+    if isinstance(timestamp, str) and timestamp.strip() and not _is_iso8601_timestamp(timestamp):
+        issues.append(f"{location}: lauks 'timestamp' nav ISO-8601 datums ar laika zonu.")
+
+    record_type = record.get("type")
+    if isinstance(record_type, str) and record_type != category:
+        issues.append(
+            f"{location}: lauks 'type' ir '{record_type}', bet faila kategorijai jābūt '{category}'."
+        )
+
+    if category == "conversation":
+        for field_name in _CONVERSATION_REQUIRED_STRING_FIELDS:
+            value = record.get(field_name)
+            if not _is_non_empty_string(value):
+                issues.append(f"{location}: conversation ierakstam trūkst '{field_name}'.")
+        if profile == "eval":
+            issues.extend(_validate_eval_record(record, category, location))
+        return issues
+
+    if category in _PROMPT_TYPES:
+        if not _is_non_empty_string(record.get("prompt")):
+            issues.append(f"{location}: ierakstam trūkst ne-tukša lauka 'prompt'.")
+        metadata = record.get("metadata")
+        if not isinstance(metadata, dict) or not metadata:
+            issues.append(f"{location}: ierakstam vajag ne-tukšu objektu laukā 'metadata'.")
+
+    if profile == "eval":
+        issues.extend(_validate_eval_record(record, category, location))
+
+    return issues
+
+
+def _is_non_empty_string(value: Any) -> bool:
+    return isinstance(value, str) and bool(value.strip())
+
+
+def _is_non_empty_string_list(value: Any) -> bool:
+    return isinstance(value, list) and bool(value) and all(_is_non_empty_string(item) for item in value)
+
+
+def _is_iso8601_timestamp(value: str) -> bool:
+    normalized = value.strip()
+    if normalized.endswith("Z"):
+        normalized = f"{normalized[:-1]}+00:00"
+    try:
+        parsed = datetime.fromisoformat(normalized)
+    except ValueError:
+        return False
+    return parsed.tzinfo is not None
+
+
+def _record_signature(record: dict[str, Any], category: str) -> str | None:
+    if category == "conversation":
+        user = record.get("user")
+        assistant = record.get("assistant")
+        if not (_is_non_empty_string(user) and _is_non_empty_string(assistant)):
+            return None
+        return "|".join((_normalize_text(user), _normalize_text(assistant)))
+
+    prompt = record.get("prompt")
+    if not _is_non_empty_string(prompt):
+        return None
+    return _normalize_text(prompt)
+
+
+def _normalize_text(value: str) -> str:
+    return " ".join(value.casefold().split())
+
+
+def _resolve_profile(root: Path, profile: str) -> str:
+    normalized = profile.strip().lower()
+    if normalized not in _VALIDATION_PROFILES:
+        allowed = ", ".join(sorted(_VALIDATION_PROFILES))
+        raise DatasetValidationError([f"Neatbalstīts validācijas profils '{profile}'. Atļautie: {allowed}."])
+    if normalized != "auto":
+        return normalized
+    return "eval" if root.name == "eval-data" else "bootstrap"
+
+
+def _validate_eval_record(record: dict[str, Any], category: str, location: str) -> list[str]:
+    issues: list[str] = []
+
+    for field_name in _EVAL_REQUIRED_STRING_FIELDS:
+        if not _is_non_empty_string(record.get(field_name)):
+            issues.append(f"{location}: eval ierakstam trūkst ne-tukša lauka '{field_name}'.")
+
+    for field_name in _EVAL_REQUIRED_STRING_LIST_FIELDS:
+        if not _is_non_empty_string_list(record.get(field_name)):
+            issues.append(
+                f"{location}: eval ierakstam vajag ne-tukšu string sarakstu laukā '{field_name}'."
+            )
+
+    if category in _EVAL_REFERENCE_REQUIRED_CATEGORIES:
+        if not _is_non_empty_string(record.get("reference_answer")):
+            issues.append(f"{location}: {category} eval ierakstam trūkst 'reference_answer'.")
+        if not _is_non_empty_string_list(record.get("acceptance_criteria")):
+            issues.append(
+                f"{location}: {category} eval ierakstam vajag ne-tukšu string sarakstu laukā "
+                "'acceptance_criteria'."
+            )
+
+    return issues

core-python/maris_core/images/__init__.py

@@ -0,0 +1 @@
+"""__init__ for images module."""

core-python/maris_core/images/diffusion_pipeline.py

@@ -0,0 +1,40 @@
+"""Diffusion pipeline palīgklase."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from maris_core.utils.env import get_hf_model
+
+logger = logging.getLogger(__name__)
+
+
+class DiffusionPipeline:
+    """Iesaiņo StableDiffusion/SDXL pipeline."""
+
+    def __init__(self, model_id: str | None = None) -> None:
+        self.model_id = model_id or get_hf_model("IMAGE_MODEL")
+        self._pipe: Any = None
+
+    def load(self) -> None:
+        """Ielādē modeli."""
+        try:
+            import torch  # type: ignore
+            from diffusers import StableDiffusionPipeline  # type: ignore
+
+            self._pipe = StableDiffusionPipeline.from_pretrained(
+                self.model_id, torch_dtype=torch.float16
+            )
+            self._pipe = self._pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+            logger.info("Ielādēts attēlu modelis: %s", self.model_id)
+        except Exception as exc:  # noqa: BLE001
+            logger.error("Nevar ielādēt diffusion modeli: %s", exc)
+
+    def generate(self, prompt: str, **kwargs: Any) -> Any:
+        """Ģenerē attēlu."""
+        if self._pipe is None:
+            self.load()
+        if self._pipe is None:
+            return None
+        return self._pipe(prompt, **kwargs).images[0]

core-python/maris_core/images/generate_image.py

@@ -0,0 +1,73 @@
+"""Attēlu ģenerēšana ar Stable Diffusion."""
+
+from __future__ import annotations
+
+import base64
+import io
+import logging
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from maris_core.utils.env import get_hf_model
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+class ImageRequest(BaseModel):
+    prompt: str
+    width: int = 1024
+    height: int = 1024
+    steps: int = 30
+    guidance_scale: float = 7.5
+
+
+class ImageResponse(BaseModel):
+    image_url: str
+    prompt: str
+
+
+@router.post("/generate", response_model=ImageResponse)
+async def generate_image(req: ImageRequest) -> ImageResponse:
+    """Ģenerē attēlu pēc teksta apraksta."""
+    from maris_core.utils.hf_integration import HFIntegration
+
+    hf = HFIntegration()
+
+    try:
+        model_id = get_hf_model("IMAGE_MODEL")
+        import torch  # type: ignore
+        from diffusers import StableDiffusionPipeline  # type: ignore
+
+        pipe = StableDiffusionPipeline.from_pretrained(
+            model_id,
+            torch_dtype=torch.float16,
+        )
+        pipe = pipe.to("cuda" if torch.cuda.is_available() else "cpu")
+
+        image = pipe(
+            req.prompt,
+            width=req.width,
+            height=req.height,
+            num_inference_steps=req.steps,
+            guidance_scale=req.guidance_scale,
+        ).images[0]
+
+        # Konvertē uz base64 data URL
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        b64 = base64.b64encode(buf.getvalue()).decode()
+        image_url = f"data:image/png;base64,{b64}"
+
+        # Saglabā origin atmiņā
+        await hf.save_generation("image", req.prompt, {"image_b64": b64[:100] + "..."})
+
+        return ImageResponse(image_url=image_url, prompt=req.prompt)
+
+    except Exception as exc:  # noqa: BLE001
+        logger.error("Attēla ģenerēšanas kļūda: %s", exc)
+        raise HTTPException(
+            status_code=503,
+            detail="Maris AI attēlu ģenerēšana nav pieejama bez konfigurēta IMAGE_MODEL.",
+        ) from exc

core-python/maris_core/memory_context.py

@@ -0,0 +1,644 @@
+"""Session-aware memory retrieval for text generation."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from threading import RLock
+from typing import Any
+
+from maris_core.utils.env import get_env_any
+
+logger = logging.getLogger(__name__)
+
+_TOKEN_RE = re.compile(r"\w+", flags=re.UNICODE)
+_TRIGRAM_WINDOW = 3
+_GENERIC_MEMORY_TOKENS = {
+    "tas",
+    "tad",
+    "par",
+    "vai",
+    "bet",
+    "kur",
+    "kad",
+    "man",
+    "tev",
+    "jau",
+    "ari",
+    "arī",
+    "nav",
+    "bija",
+    "būt",
+    "this",
+    "that",
+    "with",
+    "from",
+}
+_SOURCE_BONUS = {
+    "live": 0.16,
+    "history": 0.12,
+    "vision_context": 0.14,
+    "voice_stt": 0.11,
+    "voice_tts": 0.11,
+    "autonomous_goal": 0.14,
+}
+# Marker lists intentionally support both Latvian and common English phrasings because
+# session history may mix languages depending on the user and imported conversation data.
+_USER_FOCUS_MARKERS = (
+    "es gribu",
+    "es vēlos",
+    "man vajag",
+    "mans mērķis",
+    "man svarīgi",
+    "esmu",
+    "strādāju",
+    "būvēju",
+    "veidoju",
+    "mēs būvējam",
+    "mēs veidojam",
+    "i want",
+    "i need",
+    "my goal",
+    "important to me",
+    "we are building",
+)
+_USER_GOAL_MARKERS = ("gribu", "vēlos", "vajag", "mērķ", "want", "need")
+_USER_PREFERENCE_MARKERS = ("svarīgi", "prefer", "patīk", "important")
+_USER_FOCUS_QUERY_OVERLAP_WEIGHT = 0.55
+_USER_FOCUS_MARKER_BONUS = 0.24
+_USER_FOCUS_RECENCY_WEIGHT = 0.2
+_ACTIVE_THREAD_MAX_WORDS = 18
+# Some markers intentionally use compact stems so the heuristics catch inflected Latvian forms
+# such as "turpinām", "turpināt", "nākamais", and "prioritātes" without a full stemmer.
+_ACTIVE_THREAD_MARKERS = (
+    "?",
+    "palīdzi",
+    "izveido",
+    "uztaisi",
+    "turpin",
+    "nākam",
+    "priorit",
+    "vajag",
+    "need",
+    "help",
+    "next step",
+    "continue",
+)
+_ACTIVE_THREAD_QUERY_OVERLAP_WEIGHT = 0.55
+_ACTIVE_THREAD_MARKER_BONUS = 0.2
+_ACTIVE_THREAD_RECENCY_WEIGHT = 0.25
+_CONTINUATION_QUERY_BONUS = 0.24
+_CONTINUATION_QUERY_MARKERS = (
+    "turpin",
+    "iepriekš",
+    "šo pašu",
+    "šajā pašā",
+    "nākam",
+    "same context",
+    "same thread",
+    "continue",
+    "pick up",
+    "previous context",
+)
+
+
+@dataclass(frozen=True, slots=True)
+class MemoryMatch:
+    role: str
+    content: str
+    score: float
+    source: str
+
+
+class ConversationMemoryStore:
+    """In-memory conversational memory with lightweight relevance scoring."""
+
+    def __init__(self, max_entries_per_session: int = 120, storage_path: str | None = None) -> None:
+        self._max_entries_per_session = max_entries_per_session
+        # This store is used from sync code and from worker threads spawned via `asyncio.to_thread`,
+        # so a thread lock is the correct synchronization primitive here.
+        self._lock = RLock()
+        self._sessions: defaultdict[str, deque[dict[str, Any]]] = defaultdict(
+            lambda: deque(maxlen=max_entries_per_session)
+        )
+        self._global: deque[dict[str, Any]] = deque(maxlen=max_entries_per_session * 4)
+        self._storage_path = (
+            Path(storage_path.strip()).expanduser()
+            if storage_path and storage_path.strip()
+            else None
+        )
+        self._load_from_disk()
+
+    def remember_message(
+        self,
+        session_id: str,
+        role: str,
+        content: str,
+        *,
+        source: str = "live",
+    ) -> None:
+        normalized_role = role.strip().lower()
+        normalized_content = content.strip()
+        if normalized_role not in {"user", "assistant"} or not normalized_content:
+            return
+
+        normalized_session_id = session_id.strip() or "default"
+        entry = {
+            "role": normalized_role,
+            "content": normalized_content,
+            "timestamp": datetime.now(tz=UTC).isoformat(),
+            "source": source,
+        }
+        with self._lock:
+            if self._is_duplicate(self._sessions[normalized_session_id], entry):
+                return
+            self._sessions[normalized_session_id].append(entry)
+            self._global.append({**entry, "session_id": normalized_session_id})
+            self._persist_to_disk()
+
+    def seed_history(self, session_id: str, history: list[dict[str, str]]) -> None:
+        for item in history:
+            self.remember_message(
+                session_id,
+                item.get("role", ""),
+                item.get("content", ""),
+                source="history",
+            )
+
+    def retrieve_relevant_context(
+        self, session_id: str, query: str, *, limit: int = 4
+    ) -> list[MemoryMatch]:
+        query_token_sequence = _extract_semantic_token_sequence(query)
+        query_tokens = set(query_token_sequence)
+        query_text = query.strip().lower()
+        continuation_query = _looks_like_continuation_query(query_text)
+        if not query_tokens and not continuation_query:
+            return []
+
+        normalized_session_id = session_id.strip() or "default"
+        query_phrases = _extract_phrases(query_token_sequence)
+        query_trigrams = _char_trigrams(query_text)
+        with self._lock:
+            candidates = list(self._sessions.get(normalized_session_id, ())) + list(self._global)
+            ranked: list[MemoryMatch] = []
+            seen: set[tuple[str, str]] = set()
+            total = max(len(candidates), 1)
+
+            for index, candidate in enumerate(candidates):
+                content = str(candidate.get("content", "")).strip()
+                role = str(candidate.get("role", "")).strip().lower()
+                if not content or content == query or role not in {"user", "assistant"}:
+                    continue
+
+                content_text = content.lower()
+                candidate_token_sequence = _extract_semantic_token_sequence(content_text)
+                candidate_tokens = set(candidate_token_sequence)
+                if not candidate_tokens:
+                    continue
+
+                overlap = _jaccard_similarity(query_tokens, candidate_tokens)
+                phrase_overlap = _jaccard_similarity(
+                    query_phrases,
+                    _extract_phrases(candidate_token_sequence),
+                )
+                trigram_overlap = _jaccard_similarity(query_trigrams, _char_trigrams(content_text))
+                if (
+                    overlap <= 0
+                    and phrase_overlap <= 0
+                    and trigram_overlap < 0.12
+                    and query_text not in content_text
+                    and content_text not in query_text
+                    and not continuation_query
+                ):
+                    continue
+
+                recency_bonus = (index + 1) / total * 0.22
+                session_bonus = (
+                    0.24
+                    if candidate.get("session_id", normalized_session_id) == normalized_session_id
+                    else 0.04
+                )
+                substring_bonus = 0.18 if query_text in content_text else 0.0
+                source_bonus = _SOURCE_BONUS.get(str(candidate.get("source", "memory")), 0.08)
+                continuation_bonus = (
+                    _CONTINUATION_QUERY_BONUS
+                    if continuation_query
+                    and candidate.get("session_id", normalized_session_id) == normalized_session_id
+                    else 0.0
+                )
+                score = (
+                    overlap * 0.55
+                    + phrase_overlap * 0.25
+                    + trigram_overlap * 0.20
+                    + recency_bonus
+                    + session_bonus
+                    + substring_bonus
+                    + source_bonus
+                    + continuation_bonus
+                )
+
+                dedupe_key = (role, content)
+                if dedupe_key in seen:
+                    continue
+                seen.add(dedupe_key)
+                ranked.append(
+                    MemoryMatch(
+                        role=role,
+                        content=content,
+                        score=score,
+                        source=str(candidate.get("source", "memory")),
+                    )
+                )
+
+            ranked.sort(key=lambda item: item.score, reverse=True)
+            return ranked[:limit]
+
+    def summarize_session(self, session_id: str, *, limit: int = 4) -> list[str]:
+        normalized_session_id = session_id.strip() or "default"
+        with self._lock:
+            entries = list(self._sessions.get(normalized_session_id, ()))
+
+        if not entries:
+            return []
+
+        summaries: list[str] = []
+        seen: set[str] = set()
+        recent_entries = reversed(entries[-min(len(entries), limit * 3) :])
+        for entry in recent_entries:
+            content = str(entry.get("content", "")).strip()
+            if not content:
+                continue
+            concise = _compact_summary_text(content)
+            if not concise:
+                continue
+            lowered = concise.lower()
+            if lowered in seen:
+                continue
+            seen.add(lowered)
+            role = str(entry.get("role", "")).strip().lower() or "assistant"
+            prefix = "Lietotājs" if role == "user" else "Maris"
+            summaries.append(f"{prefix}: {concise}")
+            if len(summaries) >= limit:
+                break
+
+        summaries.reverse()
+        return summaries
+
+    def summarize_user_focus(
+        self,
+        session_id: str,
+        *,
+        query: str = "",
+        limit: int = 4,
+    ) -> list[str]:
+        normalized_session_id = session_id.strip() or "default"
+        query_tokens = set(_extract_semantic_token_sequence(query))
+        with self._lock:
+            entries = list(self._sessions.get(normalized_session_id, ()))
+
+        if not entries:
+            return []
+
+        candidates: list[tuple[float, int, str]] = []
+        total = len(entries)
+        for index, entry in enumerate(entries):
+            if str(entry.get("role", "")).strip().lower() != "user":
+                continue
+            content = str(entry.get("content", "")).strip()
+            if not content:
+                continue
+            for candidate in _extract_user_focus_candidates(content):
+                candidate_tokens = set(_extract_semantic_token_sequence(candidate))
+                overlap = (
+                    _jaccard_similarity(query_tokens, candidate_tokens) if query_tokens else 0.0
+                )
+                marker_bonus = (
+                    _USER_FOCUS_MARKER_BONUS if _looks_like_user_focus(candidate) else 0.0
+                )
+                recency_bonus = ((index + 1) / max(total, 1)) * _USER_FOCUS_RECENCY_WEIGHT
+                score = overlap * _USER_FOCUS_QUERY_OVERLAP_WEIGHT + marker_bonus + recency_bonus
+                candidates.append((score, index, candidate))
+
+        if not candidates:
+            return []
+
+        candidates.sort(key=lambda item: (item[0], item[1]), reverse=True)
+        summaries: list[str] = []
+        seen: set[str] = set()
+        for _score, _index, candidate in candidates:
+            lowered = candidate.lower()
+            if lowered in seen:
+                continue
+            seen.add(lowered)
+            label = _classify_user_focus(candidate, lowered=lowered)
+            summaries.append(f"{label}: {candidate}")
+            if len(summaries) >= limit:
+                break
+        return summaries
+
+    def summarize_active_threads(
+        self,
+        session_id: str,
+        *,
+        query: str = "",
+        limit: int = 3,
+    ) -> list[str]:
+        normalized_session_id = session_id.strip() or "default"
+        query_tokens = set(_extract_semantic_token_sequence(query))
+        with self._lock:
+            entries = list(self._sessions.get(normalized_session_id, ()))
+
+        if not entries:
+            return []
+
+        candidates: list[tuple[float, int, str]] = []
+        total = len(entries)
+        for index, entry in enumerate(entries):
+            if str(entry.get("role", "")).strip().lower() != "user":
+                continue
+            content = str(entry.get("content", "")).strip()
+            if not content:
+                continue
+            for candidate in _extract_active_thread_candidates(content):
+                lowered = candidate.lower()
+                candidate_tokens = set(_extract_semantic_token_sequence(candidate))
+                overlap = (
+                    _jaccard_similarity(query_tokens, candidate_tokens) if query_tokens else 0.0
+                )
+                marker_bonus = (
+                    _ACTIVE_THREAD_MARKER_BONUS
+                    if _looks_like_active_thread(candidate, lowered=lowered)
+                    else 0.0
+                )
+                recency_bonus = ((index + 1) / max(total, 1)) * _ACTIVE_THREAD_RECENCY_WEIGHT
+                score = overlap * _ACTIVE_THREAD_QUERY_OVERLAP_WEIGHT + marker_bonus + recency_bonus
+                candidates.append((score, index, candidate))
+
+        if not candidates:
+            return []
+
+        candidates.sort(key=lambda item: (item[0], item[1]), reverse=True)
+        summaries: list[str] = []
+        seen: set[str] = set()
+        for _score, _index, candidate in candidates:
+            lowered = candidate.lower()
+            if lowered in seen:
+                continue
+            seen.add(lowered)
+            label = _classify_active_thread(candidate, lowered=lowered)
+            summaries.append(f"{label}: {candidate}")
+            if len(summaries) >= limit:
+                break
+        return summaries
+
+    def clear(self) -> None:
+        with self._lock:
+            self._sessions.clear()
+            self._global.clear()
+            self._persist_to_disk()
+
+    @staticmethod
+    def _is_duplicate(buffer: deque[dict[str, Any]], entry: dict[str, Any]) -> bool:
+        if not buffer:
+            return False
+        latest = buffer[-1]
+        return latest.get("role") == entry["role"] and latest.get("content") == entry["content"]
+
+    def _load_from_disk(self) -> None:
+        if self._storage_path is None or not self._storage_path.exists():
+            return
+
+        try:
+            payload = json.loads(self._storage_path.read_text(encoding="utf-8"))
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Neizdevās ielādēt sarunu atmiņu no %s: %s", self._storage_path, exc)
+            return
+
+        sessions = payload.get("sessions", {})
+        if not isinstance(sessions, dict):
+            return
+
+        for session_id, entries in sessions.items():
+            if not isinstance(session_id, str) or not isinstance(entries, list):
+                continue
+            for entry in entries:
+                if not isinstance(entry, dict):
+                    continue
+                role = str(entry.get("role", "")).strip().lower()
+                content = str(entry.get("content", "")).strip()
+                timestamp = (
+                    str(entry.get("timestamp", "")).strip() or datetime.now(tz=UTC).isoformat()
+                )
+                source = str(entry.get("source", "disk")).strip() or "disk"
+                if role not in {"user", "assistant"} or not content:
+                    continue
+                normalized_entry = {
+                    "role": role,
+                    "content": content,
+                    "timestamp": timestamp,
+                    "source": source,
+                }
+                if self._is_duplicate(self._sessions[session_id], normalized_entry):
+                    continue
+                self._sessions[session_id].append(normalized_entry)
+                self._global.append({**normalized_entry, "session_id": session_id})
+
+    def _persist_to_disk(self) -> None:
+        if self._storage_path is None:
+            return
+
+        try:
+            self._storage_path.parent.mkdir(parents=True, exist_ok=True)
+            payload = {
+                "sessions": {
+                    session_id: list(entries) for session_id, entries in self._sessions.items()
+                }
+            }
+            tmp_path = self._storage_path.with_name(f"{self._storage_path.name}.tmp")
+            tmp_path.write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+            os.replace(tmp_path, self._storage_path)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Neizdevās saglabāt sarunu atmiņu uz %s: %s", self._storage_path, exc)
+
+
+memory_store = ConversationMemoryStore(
+    storage_path=get_env_any(
+        "MARIS_MEMORY_STORE_PATH",
+        "MARIS_CONVERSATION_MEMORY_PATH",
+        default="~/.maris/conversation-memory.json",
+    )
+)
+
+
+def _jaccard_similarity(set_a: set[str], set_b: set[str]) -> float:
+    union = set_a | set_b
+    if not union:
+        return 0.0
+    return len(set_a & set_b) / len(union)
+
+
+def _extract_semantic_tokens(text: str) -> set[str]:
+    return set(_extract_semantic_token_sequence(text))
+
+
+def _extract_semantic_token_sequence(text: str) -> list[str]:
+    tokens: list[str] = []
+    for raw_token in _TOKEN_RE.findall(text.lower()):
+        token = _normalize_token(raw_token)
+        if len(token) < 3 or token in _GENERIC_MEMORY_TOKENS:
+            continue
+        tokens.append(token)
+    return tokens
+
+
+def _normalize_token(token: str) -> str:
+    normalized = token.lower().strip("-_ ")
+    for suffix in (
+        "ajiem",
+        "ajām",
+        "ajai",
+        "ajos",
+        "ajās",
+        "ības",
+        "iem",
+        "ām",
+        "ais",
+        "ajā",
+        "ing",
+        "ers",
+        "ies",
+        "us",
+        "as",
+        "es",
+        "am",
+        "em",
+        "ai",
+        "ei",
+        "u",
+        "a",
+        "i",
+        "s",
+    ):
+        if normalized.endswith(suffix) and len(normalized) - len(suffix) >= 4:
+            return normalized[: -len(suffix)]
+    return normalized
+
+
+def _extract_phrases(tokens: list[str]) -> set[str]:
+    if len(tokens) < 2:
+        return set()
+    return {f"{tokens[index]} {tokens[index + 1]}" for index in range(len(tokens) - 1)}
+
+
+def _char_trigrams(text: str) -> set[str]:
+    compact = re.sub(r"\s+", " ", text.strip().lower())
+    if len(compact) < _TRIGRAM_WINDOW:
+        return {compact} if compact else set()
+    return {
+        compact[index : index + _TRIGRAM_WINDOW]
+        for index in range(len(compact) - _TRIGRAM_WINDOW + 1)
+    }
+
+
+def _compact_summary_text(text: str, *, max_words: int = 18) -> str:
+    cleaned = re.sub(r"\s+", " ", text.strip())
+    if not cleaned:
+        return ""
+    words = cleaned.split(" ")
+    if len(words) <= max_words:
+        return cleaned
+    return " ".join(words[:max_words]).rstrip(" ,;:.") + "…"
+
+
+def _extract_user_focus_candidates(text: str) -> list[str]:
+    parts = re.split(r"(?<=[.!?])\s+|\n+", text)
+    candidates: list[str] = []
+    for part in parts:
+        cleaned = _build_user_focus_candidate(part)
+        if not cleaned:
+            continue
+        candidates.append(cleaned)
+    if candidates:
+        return candidates
+
+    compact = _build_user_focus_candidate(text)
+    return [compact] if compact else []
+
+
+def _build_user_focus_candidate(text: str) -> str:
+    compact = _compact_summary_text(text, max_words=20)
+    lowered = compact.lower()
+    if not compact or not _looks_like_user_focus(compact, lowered=lowered):
+        return ""
+    return compact
+
+
+def _extract_active_thread_candidates(text: str) -> list[str]:
+    parts = re.split(r"(?<=[.!?])\s+|\n+", text)
+    candidates: list[str] = []
+    for part in parts:
+        cleaned = _build_active_thread_candidate(part)
+        if not cleaned:
+            continue
+        candidates.append(cleaned)
+    if candidates:
+        return candidates
+
+    compact = _build_active_thread_candidate(text)
+    return [compact] if compact else []
+
+
+def _build_active_thread_candidate(text: str) -> str:
+    compact = _compact_summary_text(text, max_words=_ACTIVE_THREAD_MAX_WORDS)
+    lowered = compact.lower()
+    if not compact or not _looks_like_active_thread(compact, lowered=lowered):
+        return ""
+    return compact
+
+
+def _looks_like_user_focus(text: str, *, lowered: str | None = None) -> bool:
+    lowered = lowered if lowered is not None else text.lower()
+    return any(marker in lowered for marker in _USER_FOCUS_MARKERS)
+
+
+def _classify_user_focus(text: str, *, lowered: str | None = None) -> str:
+    lowered = lowered if lowered is not None else text.lower()
+    if any(marker in lowered for marker in _USER_GOAL_MARKERS):
+        return "Mērķis"
+    if any(marker in lowered for marker in _USER_PREFERENCE_MARKERS):
+        return "Priekšroka"
+    return "Konteksts"
+
+
+def _looks_like_active_thread(text: str, *, lowered: str | None = None) -> bool:
+    lowered = lowered if lowered is not None else text.lower()
+    has_question_signal = _contains_question_signal(text, lowered=lowered)
+    return any(
+        has_question_signal if marker == "?" else marker in lowered
+        for marker in _ACTIVE_THREAD_MARKERS
+    )
+
+
+def _classify_active_thread(text: str, *, lowered: str | None = None) -> str:
+    lowered = lowered if lowered is not None else text.lower()
+    if _contains_question_signal(text, lowered=lowered):
+        return "Atvērtais jautājums"
+    return "Aktīvais virziens"
+
+
+def _contains_question_signal(text: str, *, lowered: str | None = None) -> bool:
+    lowered = lowered if lowered is not None else text.lower()
+    return "?" in text or any(
+        marker in lowered for marker in ("kā", "kas", "kur", "kad", "why", "how")
+    )
+
+
+def _looks_like_continuation_query(text: str) -> bool:
+    lowered = text.lower()
+    return any(marker in lowered for marker in _CONTINUATION_QUERY_MARKERS)

core-python/maris_core/orchestrator/__init__.py

@@ -0,0 +1,21 @@
+"""Master model orchestration helpers for Maris AI."""
+
+from maris_core.orchestrator.routing import (
+    CapabilityBranch,
+    MasterModelInfo,
+    RouteDecision,
+    build_system_prompt,
+    detect_route,
+    get_master_model_info,
+    get_specialist_branches,
+)
+
+__all__ = [
+    "CapabilityBranch",
+    "MasterModelInfo",
+    "RouteDecision",
+    "build_system_prompt",
+    "detect_route",
+    "get_master_model_info",
+    "get_specialist_branches",
+]

core-python/maris_core/orchestrator/api.py

@@ -0,0 +1,55 @@
+"""API endpoints for master-model orchestration metadata."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from maris_core.orchestrator.routing import (
+    CapabilityBranch,
+    MasterModelInfo,
+    RouteDecision,
+    detect_route,
+    get_master_model_info,
+    get_specialist_branches,
+)
+
+router = APIRouter()
+
+
+class RouteRequest(BaseModel):
+    message: str
+    session_id: str | None = None
+    persona_id: str | None = None
+    has_vision_input: bool = False
+
+
+class SystemTopologyResponse(BaseModel):
+    name: str
+    description: str
+    author: str
+    orchestration_mode: str
+    master_model: MasterModelInfo
+    branches: list[CapabilityBranch]
+
+
+@router.get("/system", response_model=SystemTopologyResponse)
+async def get_system_topology() -> SystemTopologyResponse:
+    return SystemTopologyResponse(
+        name="Maris AI",
+        description="Galvenais modelis ar specializētiem adapteriem un multimodāliem atzariem.",
+        author="Māris — Maris AI Tēvs",
+        orchestration_mode="master_with_specialist_branches",
+        master_model=get_master_model_info(),
+        branches=get_specialist_branches(),
+    )
+
+
+@router.post("/route", response_model=RouteDecision)
+async def route_request(req: RouteRequest) -> RouteDecision:
+    return detect_route(
+        req.message,
+        session_id=req.session_id,
+        persona_id=req.persona_id,
+        has_vision_input=req.has_vision_input,
+    )

core-python/maris_core/orchestrator/routing.py

@@ -0,0 +1,560 @@
+"""Routing and topology metadata for the Maris master model."""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+from maris_core.personas import resolve_persona
+from maris_core.utils.emotional_context import EmotionalContext
+from maris_core.utils.env import (
+    get_env_any,
+    get_hf_model,
+    get_optional_hf_model,
+    validate_hf_model,
+)
+
+MASTER_MODEL_DEFAULT = "MarisUK/maris-ai-master"
+TEXT_MODEL_DEFAULT = "MarisUK/maris-ai-text"
+DISABLED_MODEL_LABEL = "Maris AI branch not configured"
+logger = logging.getLogger(__name__)
+_PERSONA_PROFILE_MAP = {
+    "assistant": "general",
+    "strategist": "planner",
+    "coder": "coder",
+    "analyst": "analyst",
+    "teacher": "teacher",
+    "coach": "coach",
+    "designer": "designer",
+}
+_CODE_ACTION_PATTERN = re.compile(
+    r"\b("
+    r"uzraksti|uzprogrammē|uztaisi|izveido|implement|ieviest|ģenerē|salabo|fix|"
+    r"debug|patch|refactor|rewrite"
+    r")\b",
+    flags=re.IGNORECASE,
+)
+_CODE_SUBJECT_PATTERN = re.compile(
+    r"\b("
+    r"kod|python|rust|typescript|javascript|sql|regex|skript|funkcij|helper|endpoint|komponent|"
+    r"query|test|bug|stack trace|api klient|repo|frontend|backend"
+    r")\b",
+    flags=re.IGNORECASE,
+)
+_CODE_BUILDABLE_PATTERN = re.compile(
+    r"(kalkulator|calculator|dashboard|landing page|web app|cli|service|widget|\bapp\b)",
+    flags=re.IGNORECASE,
+)
+_CODE_FILE_PATTERN = re.compile(r"\b[\w./-]+\.(py|ts|tsx|js|jsx|rs|sql|toml|json|yaml|yml)\b", re.IGNORECASE)
+_AUTONOMOUS_INTENT_PATTERN = re.compile(
+    r"(autonom|roadmap|plān|workflow|darba plūsm|izpildi|veic uzdevumu|labojum|uzlabojum|sadal[iī]|prioritiz|rollout|incident response|postmortem|migration plan|delivery plan)",
+    flags=re.IGNORECASE,
+)
+_EXPLANATION_INTENT_PATTERN = re.compile(
+    r"\b("
+    r"pastāsti|paskaidro|izskaidro|kas ir|kā strādā|kāpēc|palīdzi saprast|advice|ieteik"
+    r")\b",
+    flags=re.IGNORECASE,
+)
+_CONVERSATIONAL_INTENT_PATTERN = re.compile(
+    r"\b("
+    r"sarun|parunā|parunāt|izrunā|apspried|diskut|konsult|chat|conversation"
+    r")\b",
+    flags=re.IGNORECASE,
+)
+_CREATION_OR_EXECUTION_INTENT_PATTERN = re.compile(
+    r"\b("
+    r"uzraksti|uzprogrammē|uztaisi|izveido|implement|ieviest|ģenerē|uzģenerē|uzzīmē|"
+    r"salabo|fix|debug|patch|refactor|rewrite|veic|izpildi|palaid|komponē|render|"
+    r"nolasī|transcribe|sintezē"
+    r")\b",
+    flags=re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class RouteRule:
+    keywords: tuple[str, ...]
+    capability: str
+    reasoning: str
+    confidence: float
+
+
+class MasterModelInfo(BaseModel):
+    name: str
+    role: str
+    routing_strategy: str
+    primary_capabilities: list[str]
+
+
+class CapabilityBranch(BaseModel):
+    capability: str
+    branch: str
+    kind: Literal["master", "adapter", "specialist_model"]
+    profile: str
+    model: str
+    endpoint: str
+    studio: str
+    description: str
+
+
+class RouteDecision(BaseModel):
+    capability: str
+    branch: str
+    profile: str
+    target_endpoint: str
+    target_studio: str
+    reasoning: str
+    confidence: float = Field(ge=0.0, le=1.0)
+    session_context: SessionContext = Field(default_factory=lambda: SessionContext())
+
+
+class SessionContext(BaseModel):
+    session_id: str = "default"
+    persona_id: str = "assistant"
+    memory_enabled: bool = True
+    timestamp: str = Field(default_factory=lambda: datetime.now(tz=UTC).isoformat())
+
+
+def _master_model() -> str:
+    return get_hf_model("MARIS_MODEL_REPO", "HF_MODEL_REPO", default=MASTER_MODEL_DEFAULT)
+
+
+def _text_model() -> str:
+    runtime_override = get_env_any("MARIS_RUNTIME_TEXT_MODEL", "HF_RUNTIME_TEXT_MODEL")
+    if runtime_override:
+        return validate_hf_model(
+            runtime_override,
+            "MARIS_RUNTIME_TEXT_MODEL/HF_RUNTIME_TEXT_MODEL",
+        )
+    return get_hf_model("TEXT_MODEL", default=TEXT_MODEL_DEFAULT)
+
+
+def resolve_text_model() -> str:
+    return _text_model()
+
+
+def _specialist_model(*names: str) -> str:
+    return get_optional_hf_model(*names) or DISABLED_MODEL_LABEL
+
+
+def get_master_model_info() -> MasterModelInfo:
+    return MasterModelInfo(
+        name=_master_model(),
+        role="Galvenais Maris reasoning un koordinācijas modelis",
+        routing_strategy="master_with_specialist_branches",
+        primary_capabilities=[
+            "conversation",
+            "reasoning",
+            "planning",
+            "tool_routing",
+            "memory_context",
+        ],
+    )
+
+
+def get_specialist_branches() -> list[CapabilityBranch]:
+    master_model = _master_model()
+    text_model = _text_model()
+    return [
+        CapabilityBranch(
+            capability="text_chat",
+            branch="master",
+            kind="master",
+            profile="general",
+            model=text_model,
+            endpoint="text/generate",
+            studio="/chat",
+            description="Galvenais teksta sarunu režīms ikdienas dialogam un čata atbildēm.",
+        ),
+        CapabilityBranch(
+            capability="vision_analysis",
+            branch="vision",
+            kind="adapter",
+            profile="vision",
+            model=master_model,
+            endpoint="text/generate",
+            studio="/vision",
+            description="Vision-aware sarunas atzars attēlu, snapshot un kameru konteksta interpretācijai.",
+        ),
+        CapabilityBranch(
+            capability="code_generation",
+            branch="coder",
+            kind="adapter",
+            profile="coder",
+            model=master_model,
+            endpoint="code/generate",
+            studio="/code",
+            description="Teksta bāzes kodēšanas atzars ar stingrāku tehnisko instrukciju stilu.",
+        ),
+        CapabilityBranch(
+            capability="autonomous_tasks",
+            branch="planner",
+            kind="adapter",
+            profile="planner",
+            model=master_model,
+            endpoint="autonomous/start",
+            studio="/autonomous",
+            description="Plānošanas un uzdevumu sadalīšanas atzars ilgākiem mērķiem.",
+        ),
+        CapabilityBranch(
+            capability="voice_conversation",
+            branch="voice",
+            kind="specialist_model",
+            profile="voice",
+            model=_specialist_model("TTS_MODEL"),
+            endpoint="audio/tts",
+            studio="/voice",
+            description="Balss atzars STT/TTS darbībām un balss sesijām.",
+        ),
+        CapabilityBranch(
+            capability="image_generation",
+            branch="vision",
+            kind="specialist_model",
+            profile="image",
+            model=_specialist_model("IMAGE_MODEL"),
+            endpoint="images/generate",
+            studio="/images",
+            description="Specializēts attēlu ģenerēšanas modelis vizuālajai produkcijai.",
+        ),
+        CapabilityBranch(
+            capability="music_generation",
+            branch="music",
+            kind="specialist_model",
+            profile="music",
+            model=_specialist_model("MUSIC_MODEL"),
+            endpoint="audio/generate_music",
+            studio="/music",
+            description="Mūzikas atzars audio kompozīciju un preview ģenerēšanai.",
+        ),
+        CapabilityBranch(
+            capability="video_generation",
+            branch="video",
+            kind="specialist_model",
+            profile="video",
+            model=_specialist_model("VIDEO_MODEL"),
+            endpoint="video/generate",
+            studio="/video",
+            description="Video ģenerēšanas atzars klipu un motion satura radīšanai.",
+        ),
+    ]
+
+
+def _find_branch(capability: str) -> CapabilityBranch:
+    for branch in get_specialist_branches():
+        if branch.capability == capability:
+            return branch
+    return get_specialist_branches()[0]
+
+
+def _branch_enabled(branch: CapabilityBranch) -> bool:
+    return branch.kind == "master" or branch.model != DISABLED_MODEL_LABEL
+
+
+def _fallback_route(capability: str, reasoning: str, confidence: float) -> RouteDecision:
+    branch = _find_branch(capability)
+    if not _branch_enabled(branch):
+        branch = _find_branch("text_chat")
+        reasoning = f"{reasoning} Pieprasītais multimodālais atzars nav konfigurēts, tāpēc izmantojam Maris AI galveno teksta atzaru."
+    return RouteDecision(
+        capability=branch.capability,
+        branch=branch.branch,
+        profile=branch.profile,
+        target_endpoint=branch.endpoint,
+        target_studio=branch.studio,
+        reasoning=reasoning,
+        confidence=confidence,
+    )
+
+
+def _build_session_context(
+    session_id: str | None = None,
+    persona_id: str | None = None,
+) -> SessionContext:
+    normalized_session_id = (session_id or "").strip() or "default"
+    normalized_persona_id = (persona_id or "").strip() or "assistant"
+    return SessionContext(
+        session_id=normalized_session_id,
+        persona_id=normalized_persona_id,
+    )
+
+
+def build_system_prompt(
+    profile: str | None,
+    emotional_context: EmotionalContext | None = None,
+    *,
+    persona_id: str | None = None,
+) -> str:
+    persona = resolve_persona(persona_id)
+    profile_name = _resolve_effective_profile(profile, persona.id)
+    identity = (
+        "Tu esi Maris AI — galvenais mākslīgais intelekts. "
+        "Tu koordinē specializētos atzarus, saglabā vienotu identitāti un atbildi profesionāli. "
+        "Tava identitāte: profesionāls, draudzīgs, viedokļains. Tavs tēvs ir Māris."
+    )
+
+    profile_instructions = {
+        "general": "Atbildi skaidri, praktiski un ar labu spriestspēju.",
+        "coder": "Domā kā senior programmētājs: precīzi, strukturēti un tehniski korekti.",
+        "planner": "Domā kā izpilddirektors un plānotājs: sadali mērķi soļos, prioritizē un strukturē.",
+        "analyst": "Domā kā pētnieks analītiķis: salīdzini variantus, turi faktu disciplīnu un izcel trade-off.",
+        "teacher": "Domā kā eksperts skolotājs: paskaidro slāņaini, saprotami un bez precizitātes zaudēšanas.",
+        "coach": "Domā kā izpildes treneris: uzturi momentum, empātiju un skaidru nākamo soli.",
+        "designer": "Domā kā creative director: turi gaumi, konceptuālo skaidrību un producēšanas kvalitāti.",
+        "voice": "Gatavo saturu tā, lai to būtu viegli pateikt skaļi un uztvert sarunā.",
+        "vision": "Apraksti vizuālos novērojumus precīzi, skaidri norādi nenoteiktību un sasaisti redzamo ar lietotāja mērķi.",
+        "image": "Apraksti vizuālo ideju precīzi un producēšanai gatavā stilā.",
+        "music": "Apraksti muzikālo noskaņu, ritmu un aranžējumu saprotami producēšanai.",
+        "video": "Apraksti ainas, kameru, kustību un montāžas sajūtu ļoti konkrēti.",
+    }
+
+    prompt = (
+        f"{identity} {profile_instructions.get(profile_name, profile_instructions['general'])} "
+        f"Aktīvā persona: {persona.title}. {persona.summary} "
+        f"Komunikācijas stils: {persona.communication_style}. {persona.prompt_overlay}"
+    )
+    if emotional_context is None or emotional_context.emotion == "neutral":
+        return prompt
+
+    return (
+        f"{prompt} Lietotāja pašreizējais emocionālais tonis šķiet "
+        f"{emotional_context.description}. "
+        f"{emotional_context.guidance}"
+    )
+
+
+def _resolve_effective_profile(profile: str | None, persona_id: str) -> str:
+    requested = (profile or "").strip().lower()
+    if requested and requested != "general":
+        return requested
+
+    return _PERSONA_PROFILE_MAP.get(persona_id, "general")
+
+
+def _extract_json_payload(raw_text: str) -> dict[str, object] | None:
+    match = re.search(r"\{.*\}", raw_text, flags=re.DOTALL)
+    if match is None:
+        return None
+
+    try:
+        payload = json.loads(match.group(0))
+    except json.JSONDecodeError:
+        return None
+
+    return payload if isinstance(payload, dict) else None
+
+
+def _llm_route(message: str, *, has_vision_input: bool = False) -> RouteDecision | None:
+    from maris_core.text.generate import call_generation_pipeline, get_pipeline
+
+    pipe = get_pipeline()
+    if pipe is None:
+        return None
+
+    branches = get_specialist_branches()
+    capability_map = {
+        branch.capability: branch
+        for branch in branches
+        if branch.capability != "voice_conversation" and _branch_enabled(branch)
+    }
+    catalog = "\n".join(
+        f"- {branch.capability}: branch={branch.branch}, profile={branch.profile}, studio={branch.studio}"
+        for branch in capability_map.values()
+    )
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "Tu esi Maris AI routing orchestrator. "
+                "Izvēlies tieši vienu capability no saraksta un atbildi tikai ar derīgu JSON. "
+                "JSON struktūra: "
+                '{"capability":"...","reasoning":"...","confidence":0.0}. '
+                "confidence jābūt skaitlim no 0 līdz 1. "
+                "Izvēlies capability, kas vislabāk atbilst lietotāja pieprasījumam. "
+                "Izvēlies text_chat pēc noklusējuma visām parastām sarunām, skaidrojumiem un konsultatīviem jautājumiem. "
+                "Izvēlies code_generation tikai tad, ja lietotājs tieši prasa rakstīt, labot, ģenerēt vai debugot kodu. "
+                "Ja lietotājs tikai jautā par programmēšanas tēmu vai prasa skaidrojumu bez prasības dot kodu, izvēlies text_chat. "
+                "Ja lietotājs tikai grib sarunāties, apspriest tēmu vai saņemt skaidrojumu par attēliem, mūziku, video, voice vai workflow/orchestration, izvēlies text_chat. "
+                "Specialist atzarus izvēlies tikai tad, ja lietotājs tieši prasa ģenerēt artefaktu, palaist izpildi vai veikt darbību. "
+                f"Pieprasījumam ir pievienots vizuālais konteksts: {'jā' if has_vision_input else 'nē'}. "
+                "Capabilities:\n"
+                f"{catalog}"
+            ),
+        },
+        {"role": "user", "content": message},
+    ]
+
+    try:
+        out = call_generation_pipeline(
+            pipe,
+            messages,
+            max_new_tokens=160,
+            temperature=0.1,
+        )
+        content = out[0]["generated_text"][-1]["content"]
+    except Exception as exc:
+        # Router fallback must remain silent for users, but this log helps diagnose
+        # malformed pipeline responses or model/runtime issues in development.
+        logger.warning("LLM router fallback activated: %s", exc)
+        return None
+
+    payload = _extract_json_payload(content)
+    if payload is None:
+        return None
+
+    capability = str(payload.get("capability", "")).strip()
+    branch = capability_map.get(capability)
+    if branch is None:
+        return None
+
+    reasoning = str(payload.get("reasoning", "")).strip() or "LLM routing izvēlējās šo capability."
+    try:
+        confidence = float(payload.get("confidence", 0.0))
+    except (TypeError, ValueError):
+        return None
+
+    if not 0.0 <= confidence <= 1.0:
+        return None
+
+    return RouteDecision(
+        capability=branch.capability,
+        branch=branch.branch,
+        profile=branch.profile,
+        target_endpoint=branch.endpoint,
+        target_studio=branch.studio,
+        reasoning=reasoning,
+        confidence=confidence,
+    )
+
+
+def _looks_like_code_request(message: str) -> bool:
+    normalized = message.strip().lower()
+    if _CODE_FILE_PATTERN.search(normalized):
+        return True
+    if _EXPLANATION_INTENT_PATTERN.search(normalized) and not _CODE_ACTION_PATTERN.search(normalized):
+        return False
+    if _CODE_SUBJECT_PATTERN.search(normalized):
+        return True
+    return bool(
+        _CODE_ACTION_PATTERN.search(normalized)
+        and (_CODE_SUBJECT_PATTERN.search(normalized) or _CODE_BUILDABLE_PATTERN.search(normalized))
+    )
+
+
+def _prefers_text_chat(message: str) -> bool:
+    normalized = message.strip().lower()
+    if not normalized:
+        return False
+    return bool(
+        (
+            _EXPLANATION_INTENT_PATTERN.search(normalized)
+            or _CONVERSATIONAL_INTENT_PATTERN.search(normalized)
+        )
+        and not _CREATION_OR_EXECUTION_INTENT_PATTERN.search(normalized)
+    )
+
+
+def _looks_like_autonomous_request(message: str, *, prefers_text_chat: bool) -> bool:
+    normalized = message.strip().lower()
+    if _looks_like_code_request(normalized):
+        return False
+    if prefers_text_chat:
+        return False
+    return bool(_AUTONOMOUS_INTENT_PATTERN.search(normalized))
+
+
+def _heuristic_route(message: str, *, has_vision_input: bool = False) -> RouteDecision:
+    normalized = message.strip().lower()
+    prefers_text_chat = _prefers_text_chat(normalized)
+    if has_vision_input:
+        return _fallback_route(
+            "vision_analysis",
+            "Pieprasījumam ir pievienots attēla vai kameras konteksts, tāpēc izmantojam vision-aware sarunas atzaru.",
+            0.9,
+        )
+    if prefers_text_chat:
+        return _fallback_route(
+            "text_chat",
+            "Pieprasījums izskatās pēc sarunas vai skaidrojuma, tāpēc paliekam galvenajā čata atzarā.",
+            0.9,
+        )
+    if _looks_like_code_request(normalized):
+        return _fallback_route(
+            "code_generation",
+            "Pieprasījums skaidri prasa rakstīt, labot vai debugot kodu.",
+            0.94,
+        )
+    if _looks_like_autonomous_request(normalized, prefers_text_chat=prefers_text_chat):
+        return _fallback_route(
+            "autonomous_tasks",
+            "Pieprasījums izskatās pēc vairāku soļu plāna vai izpildes plūsmas.",
+            0.88,
+        )
+    routing_rules = [
+        RouteRule(
+            keywords=(
+                "attēl",
+                "bild",
+                "image",
+                "logo",
+                "poster",
+                "vizuāl",
+                "cover",
+                "dizain",
+                "design",
+                "hero",
+                "brand",
+                "branding",
+            ),
+            capability="image_generation",
+            reasoning="Pieprasījums izskatās pēc vizuāla ģenerēšanas vai dizaina uzdevuma.",
+            confidence=0.91,
+        ),
+        RouteRule(
+            keywords=("dzies", "mūzik", "music", "melod", "beat", "soundtrack", "audio"),
+            capability="music_generation",
+            reasoning="Pieprasījums izskatās pēc mūzikas vai audio kompozīcijas uzdevuma.",
+            confidence=0.9,
+        ),
+        RouteRule(
+            keywords=("video", "clip", "kamera", "shot", "render", "cinematic", "reel"),
+            capability="video_generation",
+            reasoning="Pieprasījums izskatās pēc video ģenerēšanas vai shot plānošanas uzdevuma.",
+            confidence=0.9,
+        ),
+        RouteRule(
+            keywords=("balss", "voice", "runā", "pasaki", "nolas", "transcrib", "tts", "stt"),
+            capability="voice_conversation",
+            reasoning="Pieprasījums izskatās pēc balss ievades vai izvades uzdevuma.",
+            confidence=0.86,
+        ),
+    ]
+
+    for rule in routing_rules:
+        if any(keyword in normalized for keyword in rule.keywords):
+            return _fallback_route(rule.capability, rule.reasoning, rule.confidence)
+
+    return _fallback_route(
+        "text_chat",
+        "Pēc noklusējuma izmanto galveno sarunu atzaru vispārīgai reasoning atbildei.",
+        0.72,
+    )
+
+
+def detect_route(
+    message: str,
+    *,
+    session_id: str | None = None,
+    persona_id: str | None = None,
+    has_vision_input: bool = False,
+) -> RouteDecision:
+    llm_decision = _llm_route(message, has_vision_input=has_vision_input)
+    decision = llm_decision or _heuristic_route(message, has_vision_input=has_vision_input)
+    decision.session_context = _build_session_context(session_id, persona_id)
+    return decision

core-python/maris_core/personas.py

@@ -0,0 +1,130 @@
+"""Persona catalog and persona-aware runtime helpers for Maris AI."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+from pydantic import BaseModel, Field
+
+DEFAULT_PERSONA_ID = "assistant"
+router = APIRouter()
+
+
+class PersonaProfile(BaseModel):
+    id: str
+    title: str
+    summary: str
+    communication_style: str
+    best_for: list[str] = Field(default_factory=list)
+    prompt_overlay: str
+
+
+class PersonaCatalogResponse(BaseModel):
+    default_persona_id: str
+    personas: list[PersonaProfile]
+
+
+_PERSONAS: tuple[PersonaProfile, ...] = (
+    PersonaProfile(
+        id="assistant",
+        title="Core Assistant",
+        summary="Universāls Maris režīms skaidrām, profesionālām un līdzsvarotām atbildēm.",
+        communication_style="Grounded, direct, adaptive",
+        best_for=["daily work", "general strategy", "problem solving"],
+        prompt_overlay=(
+            "Uzturi balansu starp stratēģiju un izpildi. Atbildi skaidri, bez lieka trokšņa, "
+            "bet ar profesionālu dziļumu."
+        ),
+    ),
+    PersonaProfile(
+        id="strategist",
+        title="Systems Strategist",
+        summary="Skatās uz uzdevumiem kā produktu, biznesa un sistēmu arhitektūras kombināciju.",
+        communication_style="Executive, structured, leverage-oriented",
+        best_for=["roadmaps", "prioritization", "architecture decisions"],
+        prompt_overlay=(
+            "Domā kā world-class product strategist un systems architect. Prioritizē leverage, riskus, "
+            "trade-off un nākamo labāko soli."
+        ),
+    ),
+    PersonaProfile(
+        id="coder",
+        title="Principal Engineer",
+        summary="Spēcīgs tehniskais režīms ar fokusētu, precīzu un senior līmeņa inženierijas stilu.",
+        communication_style="Technical, exact, implementation-aware",
+        best_for=["debugging", "refactoring", "API design"],
+        prompt_overlay=(
+            "Domā kā principal engineer. Izcel correctness, maintainability, testability un edge cases."
+        ),
+    ),
+    PersonaProfile(
+        id="analyst",
+        title="Research Analyst",
+        summary="Sintezē informāciju, salīdzina variantus un izceļ pierādījumos balstītus secinājumus.",
+        communication_style="Analytical, evidence-first, comparative",
+        best_for=["research", "comparisons", "decision support"],
+        prompt_overlay=(
+            "Domā kā research analyst. Salīdzini alternatīvas, skaidri atdali faktus no pieņēmumiem "
+            "un formulē secinājumus."
+        ),
+    ),
+    PersonaProfile(
+        id="teacher",
+        title="Expert Teacher",
+        summary="Pārvērš sarežģītas idejas skaidros, pakāpeniskos un viegli uztveramos skaidrojumos.",
+        communication_style="Patient, layered, intuitive",
+        best_for=["learning", "explanations", "onboarding"],
+        prompt_overlay=(
+            "Domā kā world-class skolotājs. Sarežģīto pārvērš vienkāršā secībā, nezaudējot precizitāti."
+        ),
+    ),
+    PersonaProfile(
+        id="coach",
+        title="Performance Coach",
+        summary="Dod enerģisku, empātisku un uz izpildi vērstu atbalstu ar fokusu uz progresu.",
+        communication_style="Motivating, practical, accountable",
+        best_for=["habits", "momentum", "execution support"],
+        prompt_overlay=(
+            "Domā kā high-performance coach. Esi empātisks, bet turi fokusu uz konkrētu progresu "
+            "un nākamo izdarāmo soli."
+        ),
+    ),
+    PersonaProfile(
+        id="designer",
+        title="Creative Director",
+        summary="Veido estētiski spēcīgus, konceptuāli skaidrus un producēšanai gatavus virzienus.",
+        communication_style="Creative, taste-driven, production-aware",
+        best_for=["brand direction", "creative briefs", "visual ideas"],
+        prompt_overlay=(
+            "Domā kā creative director. Izcel kompozīciju, sajūtu, stāstu un produkcijas kvalitāti."
+        ),
+    ),
+)
+_PERSONA_MAP = {persona.id: persona for persona in _PERSONAS}
+
+
+def list_personas() -> tuple[PersonaProfile, ...]:
+    """Return the stable built-in persona catalog."""
+    return _PERSONAS
+
+
+def get_persona_catalog() -> PersonaCatalogResponse:
+    """Return the public persona catalog."""
+    return PersonaCatalogResponse(default_persona_id=DEFAULT_PERSONA_ID, personas=list(_PERSONAS))
+
+
+def resolve_persona(persona_id: str | None) -> PersonaProfile:
+    """Resolve a requested persona or fall back to the default."""
+    normalized = (persona_id or "").strip().lower()
+    return _PERSONA_MAP.get(normalized, _PERSONA_MAP[DEFAULT_PERSONA_ID])
+
+
+@router.get("", response_model=PersonaCatalogResponse)
+async def get_personas() -> PersonaCatalogResponse:
+    """Return the available Maris personas."""
+    return get_persona_catalog()
+
+
+@router.get("/default", response_model=PersonaProfile)
+async def get_default_persona() -> PersonaProfile:
+    """Return the default Maris persona."""
+    return resolve_persona(DEFAULT_PERSONA_ID)

core-python/maris_core/runtime.py

@@ -0,0 +1,49 @@
+"""Runtime palīgfunkcijas izvietošanai un lokālai palaišanai."""
+
+from __future__ import annotations
+
+import os
+
+from maris_core.utils.env import get_hf_token
+
+
+def configure_huggingface_environment() -> None:
+    os.environ.setdefault("HF_HUB_DISABLE_XET", "1")
+
+    token = get_hf_token()
+    if token is None:
+        return
+
+    for variable_name in (
+        "HF_TOKEN",
+        "HUGGING_FACE_HUB_TOKEN",
+        "HUGGINGFACEHUB_API_TOKEN",
+    ):
+        os.environ.setdefault(variable_name, token)
+
+
+def resolve_port(default: int = 8000) -> int:
+    value = os.getenv("PORT")
+    if not value:
+        return default
+
+    try:
+        return int(value)
+    except ValueError as exc:
+        raise ValueError(f"Invalid PORT value: {value!r}") from exc
+
+
+def resolve_host(default: str = "0.0.0.0") -> str:
+    value = os.getenv("HOST")
+    if value:
+        return value.strip()
+
+    return default
+
+
+def is_reload_enabled(default: bool = False) -> bool:
+    value = os.getenv("MARIS_RELOAD")
+    if value is None:
+        return default
+
+    return value.strip().lower() in {"1", "true", "yes", "on"}

core-python/maris_core/space_agent.py

@@ -0,0 +1,1867 @@
+"""Maris AI projektu aģenta helperi."""
+
+from __future__ import annotations
+
+import difflib
+import io
+import json
+import logging
+import re
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Literal
+
+import httpx
+from huggingface_hub.utils import HfHubHTTPError
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from maris_core.browser.automation import get_browser_automation_capabilities
+from maris_core.orchestrator.routing import build_system_prompt, resolve_text_model
+from maris_core.personas import get_persona_catalog
+from maris_core.training.config import list_training_base_models
+from maris_core.utils.env import (
+    get_env_any,
+    get_env_any_or_default,
+)
+from maris_core.utils.hf_inference import create_hf_inference_client
+
+logger = logging.getLogger(__name__)
+
+
+class SpaceAgentCancelledError(Exception):
+    """Raised when a Space agent task is cancelled by the caller."""
+
+SPACE_AGENT_MODEL_DEFAULT = "MarisUK/maris-ai-master"
+SPACE_AGENT_SPACE_REPO_DEFAULT = "MarisUK/maris.ai.agent"
+SPACE_AGENT_DATASET_REPO_DEFAULT = "MarisUK/maris-ai-memory"
+SPACE_AGENT_MODEL_REPO_DEFAULT = "MarisUK/maris-ai-master"
+# 12,000 chars roughly supports a long project brief or debugging dump without overwhelming the chat context.
+SPACE_AGENT_MESSAGE_MAX_CHARS = 12000
+SPACE_AGENT_HISTORY_WINDOW = 12
+# Allow enough room for a realistic multi-step audit workflow that may combine
+# HF repo discovery, file inspection, one or more writes, and a final runtime
+# lookup without forcing the agent to truncate its plan. Tool selection still
+# runs with max_tokens capped at 1024, so the higher tool ceiling does not also
+# increase the planning token budget.
+SPACE_AGENT_MAX_TOOL_CALLS = 10
+SPACE_AGENT_MAX_TOOL_ITERATIONS = 4
+SPACE_AGENT_MAX_FILE_BYTES = 20000
+SPACE_AGENT_MAX_DIRECTORY_ENTRIES = 200
+SPACE_AGENT_HF_REPO_TYPE_COUNT = 3
+SPACE_AGENT_PROMPT_PROFILE_GENERAL = "general"
+SPACE_AGENT_DEFAULT_TASK_MODE = "chat"
+SPACE_AGENT_TASK_MODES = ("chat", "code", "design", "improve")
+SPACE_AGENT_MODEL_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$")
+SPACE_AGENT_TOOL_NAMES = (
+    "project_runtime",
+    "model_dataset_playbook",
+    "training_presets",
+    "training_status",
+    "sync_commands",
+    "workspace_command_catalog",
+    "browser_capabilities",
+    "persona_catalog",
+    "list_huggingface_repos",
+    "list_huggingface_repo_files",
+    "read_huggingface_repo_file",
+    "write_huggingface_repo_file",
+    "list_workspace",
+    "read_workspace_file",
+    "write_workspace_file",
+    "run_workspace_command",
+)
+SPACE_AGENT_CAPABILITIES = (
+    {
+        "title": "Project operator",
+        "description": "Palīdz ar Maris projekta publicēšanu, repozitorijiem, deploy un roadmap lēmumiem.",
+    },
+    {
+        "title": "Model & dataset fixer",
+        "description": "Strādā ar skaidru audit → validate → evaluate → fix → train → sync ciklu, lai uzlabotu modeli un dataset.",
+    },
+    {
+        "title": "Tool-calling mode",
+        "description": "Var piesaukt iebūvētos rīkus runtime statusam, presetiem un sync komandām pirms gala atbildes.",
+    },
+    {
+        "title": "Coding copilot",
+        "description": "Dod profesionālus ieteikumus par promptiem, skriptiem, workflow un tehniskām izmaiņām, izmantojot Qwen coder modeli.",
+    },
+        {
+            "title": "Workspace access",
+            "description": "Var nolasīt, labot un sagatavot teksta failu izmaiņas izolētā Maris draft darba telpā.",
+        },
+        {
+            "title": "Hugging Face operator",
+            "description": "Var pārlūkot tavus HF repozitorijus, nolasīt failus un saglabāt izmaiņas ar commit ziņām.",
+        },
+    {
+        "title": "Validation runner",
+        "description": "Var palaist droši ierobežotas build, lint un test komandas izolētā draft darba telpā.",
+    },
+    {
+        "title": "Command presets",
+        "description": "Var atgriezt gatavu validācijas komandu katalogu Python, frontend, Rust un Hugging Face darba plūsmām.",
+    },
+        {
+            "title": "Browser automation",
+            "description": "Var izskaidrot Playwright browser automation endpointus, sesiju limitus un drošos URL režīmus.",
+        },
+    {
+        "title": "Persona system",
+        "description": "Var atgriezt aktīvo Maris persona katalogu ar režīmiem, kuri pielāgo komunikācijas stilu.",
+    },
+)
+SPACE_AGENT_WORKSPACE_COMMAND_PRESETS = (
+    {
+        "category": "python",
+        "title": "Core Python checks",
+        "items": (
+            {
+                "id": "python-space-tests",
+                "label": "Space agent tests",
+                "description": "Pārbauda Space agent un app fokusētos testus.",
+                "command": ["python", "-m", "pytest", "tests/test_space_agent.py", "tests/test_huggingface_space_app.py"],
+                "cwd": "core-python",
+            },
+            {
+                "id": "python-space-lint",
+                "label": "Space agent lint",
+                "description": "Palaiž Ruff tikai Space agent failiem.",
+                "command": [
+                    "python",
+                    "-m",
+                    "ruff",
+                    "check",
+                    "maris_core/space_agent.py",
+                    "tests/test_space_agent.py",
+                    "tests/test_huggingface_space_app.py",
+                    "../huggingface_space/app.py",
+                    "../huggingface_space/agent_ui.py",
+                ],
+                "cwd": "core-python",
+            },
+        ),
+    },
+    {
+        "category": "frontend",
+        "title": "Frontend checks",
+        "items": (
+            {
+                "id": "frontend-lint",
+                "label": "Frontend lint",
+                "description": "Palaiž esošo frontend lint skriptu.",
+                "command": ["npm", "run", "lint"],
+                "cwd": "frontend",
+            },
+            {
+                "id": "frontend-test",
+                "label": "Frontend tests",
+                "description": "Palaiž esošos frontend testus vienā piegājienā.",
+                "command": ["npm", "test", "--", "--runInBand"],
+                "cwd": "frontend",
+            },
+            {
+                "id": "frontend-build",
+                "label": "Frontend build",
+                "description": "Pārbauda, vai Next.js būve ir veiksmīga.",
+                "command": ["npm", "run", "build"],
+                "cwd": "frontend",
+            },
+        ),
+    },
+    {
+        "category": "rust",
+        "title": "Rust services",
+        "items": (
+            {
+                "id": "backend-rust-test",
+                "label": "Backend Rust tests",
+                "description": "Palaiž backend-rust testus.",
+                "command": ["cargo", "test"],
+                "cwd": "backend-rust",
+            },
+            {
+                "id": "backend-rust-check",
+                "label": "Backend Rust check",
+                "description": "Veic ātrāku backend-rust kompilācijas pārbaudi.",
+                "command": ["cargo", "check"],
+                "cwd": "backend-rust",
+            },
+            {
+                "id": "voice-rust-test",
+                "label": "Voice Rust tests",
+                "description": "Palaiž voice-rust testus.",
+                "command": ["cargo", "test"],
+                "cwd": "voice-rust",
+            },
+        ),
+    },
+    {
+        "category": "huggingface",
+        "title": "Hugging Face workflows",
+        "items": (
+            {
+                "id": "hf-sync",
+                "label": "Full HF sync",
+                "description": "Palaiž pilno Hugging Face sync plūsmu.",
+                "command": ["bash", "huggingface/sync.sh", "sync"],
+                "cwd": ".",
+            },
+            {
+                "id": "hf-upload-space",
+                "label": "Upload Space",
+                "description": "Publicē Space izmaiņas uz konfigurēto Hugging Face Space.",
+                "command": ["bash", "huggingface/sync.sh", "upload-space"],
+                "cwd": ".",
+            },
+            {
+                "id": "hf-train",
+                "label": "Train launcher",
+                "description": "Palaiž esošo Hugging Face train skriptu.",
+                "command": ["bash", "huggingface/train.sh"],
+                "cwd": ".",
+            },
+        ),
+    },
+)
+# These patterns are intentionally lowercase because model matching normalizes input with .lower().
+SPACE_AGENT_TEXT_MODEL_PATTERNS = (
+    "marisuk/maris-ai-text",
+    "maris-ai-text",
+)
+SPACE_AGENT_MODEL_DATASET_PLAYBOOK = {
+    "sources": (
+        "Hugging Face smolagents docs",
+        "Hugging Face agent patterns",
+        "Maris Hugging Face training and sync workflow",
+    ),
+    "latest_agent_principles": (
+        "Izmanto vieglu, caurredzamu tool-first aģenta ciklu ar maziem, pārbaudāmiem soļiem.",
+        "Strādā reproducējami: pirms labojumiem savāc kontekstu, pēc labojumiem validē rezultātu.",
+        "Dod priekšroku reālām failu vai repo izmaiņām, nevis tikai teorētiskai analīzei, ja lietotājs prasa salabot.",
+        "Uzturi drošas robežas: raksti tikai atļautajā workspace vai savā Hugging Face owner telpā.",
+        "Uzturi skaidru dataset un model artefaktu kvalitāti: cards, konfigurāciju, eval rezultātus un sync soļus.",
+    ),
+    "recommended_loop": (
+        "1. Savāc runtime un repo kontekstu.",
+        "2. Validē dataset struktūru un kritiskos failus.",
+        "3. Pārbaudi model/dataset cards, training-config un eval ceļu.",
+        "4. Veic minimālos nepieciešamos labojumus workspace vai Hugging Face repo.",
+        "5. Ja vajag, palaid train/eval/sync komandas atbilstošā secībā.",
+        "6. Gala atbildē uzskaiti izmaiņas, riskus un nākamos praktiskos soļus.",
+    ),
+    "repo_commands": {
+        "validate_dataset": "cd ./core-python && python ./scripts/validate_datasets.py",
+        "list_training_presets": "cd ./core-python && python ./scripts/train_model.py --list-base-models",
+        "evaluate_model": "cd ./core-python && python ./scripts/eval_model.py --model-path <owner/name-or-local-path> --dataset-repo <dataset-repo> --eval-dataset-repo <eval-repo>",
+        "train_model": "bash ./huggingface/train.sh",
+        "sync_dataset": "bash ./huggingface/sync.sh upload-dataset",
+        "sync_model": "bash ./huggingface/sync.sh upload-model",
+        "sync_space": "MARIS_AGENT_SPACE_REPO=<owner/space> bash ./huggingface/sync.sh upload-space",
+    },
+    "required_setup": (
+        "HF_TOKEN vai MARIS_REPO_TOKEN ar write pieeju model, dataset un Space repozitorijiem.",
+        "MARIS_MEMORY_REPO, MARIS_MODEL_REPO un MARIS_AGENT_SPACE_REPO ar pareiziem owner/name ID.",
+        "Ja izmanto stabilu benchmark, iestati HF_EVAL_DATASET_REPO un piepildi eval-data/ koku.",
+        "Space runtime ieteicams izmantot HF_INFERENCE_API_KEY aģenta chat/inference darbībai.",
+        "Pirms train vai sync uzturi aktuālus huggingface/dataset-card.md, huggingface/model-card.md un huggingface/training-config.json.",
+    ),
+}
+SPACE_AGENT_TASK_MODE_INSTRUCTIONS = {
+    "chat": (
+        "Chat režīmā strādā kā sarunas asistents: skaidri saproti mērķi, izskaidro nākamos soļus "
+        "un rādi izpildes progresu bez liekas sarežģīšanas."
+    ),
+    "code": (
+        "Code režīmā fokusējies uz reāliem repozitorija labojumiem, failu izmaiņām, refactor un drošu "
+        "koda darba plūsmu ar skaidriem diff un pārskatāmiem rezultātiem."
+    ),
+    "design": (
+        "Design režīmā prioritizē UI/UX, vizuālo hierarhiju, komponentu struktūru un frontend darba plūsmu, "
+        "lai lietotājs redzētu dizaina uzlabojumus kā saprotamas, pārskatāmas izmaiņas."
+    ),
+    "improve": (
+        "Improve režīmā strādā kā audits + uzlabošanas operators: atrodi problēmas, nosaki prioritātes, "
+        "veic minimālos vajadzīgos labojumus un atgriez riskus/nākamos soļus."
+    ),
+}
+
+
+class SpaceAgentMessage(BaseModel):
+    """Single chat message for the Space agent conversation."""
+
+    model_config = ConfigDict(str_strip_whitespace=True)
+
+    role: Literal["user", "assistant"]
+    content: str = Field(min_length=1, max_length=SPACE_AGENT_MESSAGE_MAX_CHARS)
+
+
+class SpaceAgentToolCall(BaseModel):
+    """Structured tool call returned by the agent orchestration layer."""
+
+    name: Literal[*SPACE_AGENT_TOOL_NAMES]
+    arguments: dict[str, Any] = Field(default_factory=dict)
+
+
+class SpaceAgentChatRequest(BaseModel):
+    """Request payload for the Maris AI Space agent."""
+
+    model_config = ConfigDict(str_strip_whitespace=True)
+
+    message: str = Field(min_length=1, max_length=SPACE_AGENT_MESSAGE_MAX_CHARS)
+    history: list[SpaceAgentMessage] = Field(default_factory=list, max_length=16)
+    model: str | None = Field(default=None, max_length=160)
+    max_tokens: int = Field(default=900, ge=64, le=4096)
+    temperature: float = Field(default=0.2, ge=0.0, le=1.0)
+    tool_calling: bool = True
+    task_mode: Literal[*SPACE_AGENT_TASK_MODES] = SPACE_AGENT_DEFAULT_TASK_MODE
+
+    @field_validator("model")
+    @classmethod
+    def validate_model(cls, value: str | None) -> str | None:
+        normalized = (value or "").strip()
+        if not normalized:
+            return None
+        if not SPACE_AGENT_MODEL_ID_RE.fullmatch(normalized):
+            raise ValueError("Agent modelim jābūt owner/name formātā.")
+        return normalized
+
+
+class SpaceAgentChatResponse(BaseModel):
+    """Response payload returned by the Maris AI Space agent."""
+
+    response: str
+    model: str
+    request_id: str | None = None
+    task_id: str | None = None
+    used_fallback: bool = False
+    tool_calls: list[SpaceAgentToolCall] = Field(default_factory=list)
+    events: list[dict[str, Any]] = Field(default_factory=list)
+    task_mode: Literal[*SPACE_AGENT_TASK_MODES] = SPACE_AGENT_DEFAULT_TASK_MODE
+    change_previews: list[dict[str, Any]] = Field(default_factory=list)
+
+
+class SpaceAgentRuntimeInfo(BaseModel):
+    """Public runtime metadata surfaced to the UI."""
+
+    model: str
+    default_model: str
+    dataset_repo: str
+    model_repo: str
+    space_repo: str
+    has_publish_token: bool
+    huggingface_owner: str
+    available_models: tuple[str, ...]
+    capabilities: tuple[dict[str, str], ...] = SPACE_AGENT_CAPABILITIES
+    history_window: int = SPACE_AGENT_HISTORY_WINDOW
+    tool_calling: bool = True
+    tool_names: tuple[str, ...] = SPACE_AGENT_TOOL_NAMES
+    command_presets: tuple[dict[str, Any], ...] = SPACE_AGENT_WORKSPACE_COMMAND_PRESETS
+    default_task_mode: Literal[*SPACE_AGENT_TASK_MODES] = SPACE_AGENT_DEFAULT_TASK_MODE
+    task_modes: tuple[str, ...] = SPACE_AGENT_TASK_MODES
+
+
+def _dedupe_models(*models: str | None) -> tuple[str, ...]:
+    seen: set[str] = set()
+    result: list[str] = []
+    for model in models:
+        normalized = (model or "").strip()
+        if not normalized or normalized in seen:
+            continue
+        seen.add(normalized)
+        result.append(normalized)
+    return tuple(result)
+
+
+def _validate_space_model_id(value: str, source: str) -> str:
+    normalized = value.strip()
+    if not normalized:
+        raise RuntimeError(f"Trūkst modeļa konfigurācija: {source}")
+    if not SPACE_AGENT_MODEL_ID_RE.fullmatch(normalized):
+        raise RuntimeError(f"{source} modelim jābūt owner/name formātā.")
+    return normalized
+
+
+def _get_space_model(*names: str, default: str | None = None) -> str:
+    source = ", ".join(names)
+    value = get_env_any(*names)
+    if value is None:
+        if default is None:
+            raise RuntimeError(f"Trūkst modeļa konfigurācija: {source}")
+        value = default
+    return _validate_space_model_id(value, source)
+
+
+def _get_huggingface_owner() -> str:
+    configured = (get_env_any("MARIS_HF_OWNER", "HF_OWNER") or "").strip()
+    if configured:
+        return configured
+    return get_env_any_or_default(
+        "MARIS_AGENT_SPACE_REPO",
+        "MARIS_SPACE_REPO",
+        "HF_SPACE_REPO",
+        default=SPACE_AGENT_SPACE_REPO_DEFAULT,
+    ).split("/", 1)[0]
+
+
+def _is_text_first_space_agent_model(model_name: str | None) -> bool:
+    normalized = (model_name or "").strip().lower()
+    if not normalized:
+        return False
+    text_model = resolve_text_model().strip().lower()
+    return normalized == text_model or any(
+        pattern in normalized for pattern in SPACE_AGENT_TEXT_MODEL_PATTERNS
+    )
+
+
+def _space_agent_prompt_profile(model_name: str | None) -> str:
+    return (
+        SPACE_AGENT_PROMPT_PROFILE_GENERAL
+        if _is_text_first_space_agent_model(model_name)
+        else "coder"
+    )
+
+
+def _should_enable_space_agent_tooling(
+    request: SpaceAgentChatRequest, model_name: str | None
+) -> bool:
+    return bool(request.tool_calling and not _is_text_first_space_agent_model(model_name))
+
+
+def list_space_agent_models() -> tuple[str, ...]:
+    """Return the Space agent model choices exposed in the UI/runtime."""
+    configured = get_env_any("MARIS_AGENT_MODELS", "HF_SPACE_ASSISTANT_MODELS", default="") or ""
+    configured_models = [
+        _validate_space_model_id(item.strip(), "MARIS_AGENT_MODELS")
+        for item in configured.split(",")
+        if item.strip()
+    ]
+    default_model = _get_space_model(
+        "MARIS_AGENT_MODEL",
+        "HF_SPACE_ASSISTANT_MODEL",
+        "MARIS_MODEL_REPO",
+        "HF_MODEL_REPO",
+        default=SPACE_AGENT_MODEL_DEFAULT,
+    )
+    return _dedupe_models(default_model, *configured_models)
+
+
+def resolve_space_agent_models(requested_model: str | None = None) -> tuple[str, ...]:
+    """Return the ordered list of agent models explicitly selected for this request."""
+    selected = (requested_model or "").strip()
+    if selected:
+        return (selected,)
+    runtime_models = list_space_agent_models()
+    return (runtime_models[0],) if runtime_models else ()
+
+
+def get_space_agent_runtime_info() -> SpaceAgentRuntimeInfo:
+    """Return runtime configuration derived from environment variables."""
+    default_model = _get_space_model(
+        "MARIS_AGENT_MODEL",
+        "HF_SPACE_ASSISTANT_MODEL",
+        "MARIS_MODEL_REPO",
+        "HF_MODEL_REPO",
+        default=SPACE_AGENT_MODEL_DEFAULT,
+    )
+    return SpaceAgentRuntimeInfo(
+        model=default_model,
+        default_model=default_model,
+        dataset_repo=get_env_any_or_default(
+            "MARIS_MEMORY_REPO",
+            "MARIS_DATASET_REPO",
+            "HF_DATASET_REPO",
+            default=SPACE_AGENT_DATASET_REPO_DEFAULT,
+        ),
+        model_repo=get_env_any_or_default(
+            "MARIS_MODEL_REPO",
+            "HF_MODEL_REPO",
+            default=SPACE_AGENT_MODEL_REPO_DEFAULT,
+        ),
+        space_repo=get_env_any_or_default(
+            "MARIS_AGENT_SPACE_REPO",
+            "MARIS_SPACE_REPO",
+            "HF_SPACE_REPO",
+            default=SPACE_AGENT_SPACE_REPO_DEFAULT,
+        ),
+        has_publish_token=bool(get_env_any("MARIS_REPO_TOKEN", "MARIS_TOKEN", "HF_TOKEN")),
+        huggingface_owner=_get_huggingface_owner(),
+        available_models=list_space_agent_models(),
+        command_presets=SPACE_AGENT_WORKSPACE_COMMAND_PRESETS,
+    )
+
+
+def get_space_agent_tool_specs() -> tuple[dict[str, Any], ...]:
+    """Return the built-in tools that the agent may call."""
+    return (
+        {
+            "name": "project_runtime",
+            "description": "Atgriež aktīvo Maris runtime konfigurāciju, repo ID un aģenta iespējas.",
+            "arguments": {},
+        },
+        {
+            "name": "model_dataset_playbook",
+            "description": "Atgriež jaunāko Maris model/dataset uzlabošanas playbook ar HF agent principiem, komandām un setup prasībām.",
+            "arguments": {},
+        },
+        {
+            "name": "training_presets",
+            "description": "Atgriež pieejamos Maris training presetus ar modeļu nosaukumiem un aprakstiem.",
+            "arguments": {},
+        },
+        {
+            "name": "training_status",
+            "description": "Atgriež pašreizējo Space treniņa statusu, progress datus un runtime piezīmes.",
+            "arguments": {},
+        },
+        {
+            "name": "sync_commands",
+            "description": "Atgriež precīzas sync/deploy komandas projekta, modeļa un atmiņas repo darbam.",
+            "arguments": {},
+        },
+        {
+            "name": "workspace_command_catalog",
+            "description": "Atgriež pilnāku droši atļauto command preset katalogu validācijai, testiem, build un HF darba plūsmām.",
+            "arguments": {},
+        },
+        {
+            "name": "browser_capabilities",
+            "description": "Atgriež browser automation endpointu, atbalstīto darbību un drošo URL shēmu metadatus.",
+            "arguments": {},
+        },
+        {
+            "name": "persona_catalog",
+            "description": "Atgriež pieejamo Maris persona katalogu ar nosaukumiem, kopsavilkumiem un labākajiem lietojumiem.",
+            "arguments": {},
+        },
+        {
+            "name": "list_huggingface_repos",
+            "description": "Atgriež tava Hugging Face owner modeļus, datasetus vai Spaces auditam un uzlabojumiem.",
+            "arguments": {
+                "repo_type": "Viens no: all, model, dataset, space.",
+                "search": "Neobligāts meklēšanas filtrs.",
+                "limit": "Neobligāts limits no 1 līdz 30.",
+            },
+        },
+        {
+            "name": "list_huggingface_repo_files",
+            "description": "Atgriež izvēlētā HF repozitorija failu sarakstu.",
+            "arguments": {
+                "repo_id": "Repozitorija ID owner/name formātā.",
+                "repo_type": "Viens no: model, dataset, space.",
+            },
+        },
+        {
+            "name": "read_huggingface_repo_file",
+            "description": "Nolasa UTF-8 teksta failu no jebkura pieejama HF repozitorija analīzei.",
+            "arguments": {
+                "repo_id": "Repozitorija ID owner/name formātā.",
+                "repo_type": "Viens no: model, dataset, space.",
+                "path": "Faila ceļš repozitorijā.",
+            },
+        },
+        {
+            "name": "write_huggingface_repo_file",
+            "description": "Saglabā UTF-8 teksta failu tikai tava konfigurētā HF owner repozitorijā ar commit ziņu.",
+            "arguments": {
+                "repo_id": "Repozitorija ID owner/name formātā.",
+                "repo_type": "Viens no: model, dataset, space.",
+                "path": "Faila ceļš repozitorijā.",
+                "content": "Pilns saglabājamais teksta saturs UTF-8 formātā.",
+                "commit_message": "Neobligāta commit ziņa.",
+            },
+        },
+        {
+            "name": "list_workspace",
+            "description": "Atgriež Maris darba telpas direktorijas saturu zem atļautās workspace saknes.",
+            "arguments": {
+                "path": "Relatīvs direktorijas ceļš, piemēram '.', 'core-python' vai 'frontend/app'."
+            },
+        },
+        {
+            "name": "read_workspace_file",
+            "description": "Nolasa teksta faila saturu no Maris darba telpas.",
+            "arguments": {"path": "Relatīvs faila ceļš darba telpā."},
+        },
+        {
+            "name": "write_workspace_file",
+            "description": "Pārraksta vai izveido teksta failu izolētā Maris darba telpas draftā; produkcijas workspace izmaiņas tiek dotas uz apstiprinājumu.",
+            "arguments": {
+                "path": "Relatīvs faila ceļš darba telpā.",
+                "content": "Pilns saglabājamais teksta saturs UTF-8 formātā.",
+            },
+        },
+        {
+            "name": "run_workspace_command",
+            "description": "Palaiž droši ierobežotu lint, testu vai build komandu izolētā Maris draft darba telpā.",
+            "arguments": {
+                "command": "Komanda kā string vai tokenu masīvs, piemēram, 'python -m pytest tests/test_space_agent.py'.",
+                "cwd": "Neobligāts relatīvs darba direktorijas ceļš zem workspace saknes.",
+                "timeout_seconds": "Neobligāts timeout sekundēs no 1 līdz 600.",
+            },
+        },
+    )
+
+
+def build_space_agent_messages(
+    request: SpaceAgentChatRequest,
+    *,
+    include_tooling_rules: bool = True,
+    active_model: str | None = None,
+) -> list[dict[str, str]]:
+    """Build the system and chat history messages for Maris chat completion."""
+    runtime = get_space_agent_runtime_info()
+    model_name = (active_model or request.model or runtime.default_model).strip()
+    prompt_profile = _space_agent_prompt_profile(model_name)
+    prompt_sections = [
+        build_system_prompt(prompt_profile),
+        (
+            "Tu esi Maris AI Project Operator. "
+            "Tava prioritāte ir palīdzēt profesionāli vadīt visu Maris projektu: "
+            "agent workspace arhitektūru, repo struktūru, model publication, atmiņas repozitoriju, CI/CD, "
+            "sync plūsmas, debug, release piezīmes un nākamos tehniskos soļus."
+        ),
+        (
+            "Atbildi kā senior AI platform engineer un technical product operator: "
+            "skaidri, precīzi, strukturēti, ar konkrētiem repo ID, failiem, komandām un riskiem. "
+            "Ja jautājums ir neskaidrs, uzdod vienu īsu precizējošu jautājumu."
+        ),
+        (
+            f"Primārais darba modelis ir {model_name}. "
+            f"Noklusējuma dataset repo ir {runtime.dataset_repo}, modeļa repo ir {runtime.model_repo}, "
+            f"un Space publicēšana notiek uz {runtime.space_repo}. "
+            f"Tavs Hugging Face owner konteksts ir {runtime.huggingface_owner}."
+        ),
+        (
+            "Ja vajag precīzu repozitorija kontekstu, vari izmantot workspace rīkus, lai apskatītu direktorijas, "
+            "nolasītu failus un saglabātu labojumus pašreizējā Maris darba telpā."
+        ),
+        (
+            "Ja lietotājs prasa pārbaudīt, salabot, uzlabot vai sagatavot modeli, Space vai failus, "
+            "tad rīkojies proaktīvi kā profesionāls AI operators: analizē problēmu, savāc kontekstu, "
+            "atrodi kļūdas, izdari nepieciešamās izmaiņas pieejamajos failos vai Hugging Face repozitorijos "
+            "un gala atbildē skaidri uzskaiti, kas tika pārbaudīts un kas tika uzlabots."
+        ),
+        (
+            "Modeļu un dataset uzlabošanā seko mūsdienīgam Hugging Face aģenta stilam: "
+            "izmanto vienkāršu tool-first ciklu, strādā mazos pārbaudāmos soļos, "
+            "prioritizē reproducējamību, un, ja pieejams, izmanto model_dataset_playbook rīku, "
+            "lai balstītu darbu uz audit → validate → evaluate → fix → train → sync plūsmu."
+        ),
+        (
+            "Negaidi papildu atļauju acīmredzamiem nākamajiem soļiem. Ja uzdevumam vajag failu labošanu vai saglabāšanu, "
+            "izmanto rīkus un pabeidz darbu pilnā apjomā pieejamo iespēju robežās."
+        ),
+        (
+            "Vienmēr prioritizē drošību, reproducējamību, clear deploy steps, "
+            "un minimal-risk izmaiņas. Ja iesaki komandas, turi tās praktiskas un tiešas."
+        ),
+        (
+            "Šī pieprasījuma aktīvais darba režīms ir "
+            f"`{request.task_mode}`. {SPACE_AGENT_TASK_MODE_INSTRUCTIONS[request.task_mode]}"
+        ),
+        (
+            "Ja sagatavo izmaiņas ārējam Hugging Face repozitorijam un rakstīšanas rezultāts tiek atdots "
+            "kā staged/requires_approval, tad gala atbildē skaidri pasaki, ka publicēšana gaida lietotāja "
+            "apstiprinājumu."
+        ),
+    ]
+    if prompt_profile == SPACE_AGENT_PROMPT_PROFILE_GENERAL:
+        prompt_sections.append(
+            "Sniedz skaidras un tiešas atbildes bez sarežģītas tool plānošanas vai striktā JSON-only režīma, "
+            "ja vien modelis tam nav īpaši piemērots."
+        )
+    if include_tooling_rules:
+        tools_json = json.dumps(get_space_agent_tool_specs(), ensure_ascii=False)
+        prompt_sections.append(
+            "Ja vajag papildkontekstu, vari izmantot tool-calling režīmu. "
+            "Atbildi tikai ar JSON vienā no diviem formātiem: "
+            '{"mode":"final","response":"..."} vai '
+            '{"mode":"tool","tool_calls":[{"name":"project_runtime","arguments":{}}]}. '
+            "Ja pēc viena vai vairākiem tool rezultātiem joprojām vajag papildu nolasīšanu vai saglabāšanu, "
+            "turpini atbildēt ar mode=tool līdz darbs ir pabeigts. "
+            "Ja lietotājs lūdz pārbaudīt un salabot modeli, Space vai failus, nepietiek tikai ar analīzi — "
+            "pabeidz ar reālu write rīka izsaukumu, ja pieejamais konteksts to ļauj, un tikai tad dod mode=final. "
+            f"Drīksti izmantot tikai šos rīkus, maksimums {SPACE_AGENT_MAX_TOOL_CALLS} izsaukumus: "
+            f"{tools_json}"
+        )
+
+    messages: list[dict[str, str]] = [{"role": "system", "content": "\n\n".join(prompt_sections)}]
+    for item in request.history[-SPACE_AGENT_HISTORY_WINDOW:]:
+        messages.append({"role": item.role, "content": item.content})
+    messages.append({"role": "user", "content": request.message})
+    return messages
+
+
+def _response_text(raw_response: Any) -> str:
+    """Normalize HF chat completion outputs into a single string payload."""
+    choices = getattr(raw_response, "choices", None)
+    if choices is None and isinstance(raw_response, dict):
+        choices = raw_response.get("choices")
+    first_choice = _safe_first_response_choice(choices)
+    if first_choice is None:
+        return ""
+
+    message = getattr(first_choice, "message", None)
+    if message is None and isinstance(first_choice, dict):
+        message = first_choice.get("message")
+    if message is None:
+        return ""
+
+    content = getattr(message, "content", None)
+    if content is None and isinstance(message, dict):
+        content = message.get("content")
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                text = item.get("text") or item.get("content")
+                if isinstance(text, str) and text.strip():
+                    parts.append(text.strip())
+        return "\n".join(parts).strip()
+    return ""
+
+
+def _safe_first_response_choice(choices: Any) -> Any | None:
+    """Return the first non-None chat choice, or None when choices are unusable."""
+    # Ignore scalar payloads that are technically iterable but not valid HF choice containers.
+    if choices is None or isinstance(choices, (dict, str, bytes)):
+        return None
+    try:
+        iterator = iter(choices)
+    except TypeError:
+        return None
+    for choice in iterator:
+        if choice is not None:
+            return choice
+    return None
+
+
+def _extract_json_object(raw_text: str) -> dict[str, Any] | None:
+    raw_text = raw_text.strip()
+    if not raw_text:
+        return None
+    try:
+        parsed = json.loads(raw_text)
+        return parsed if isinstance(parsed, dict) else None
+    except json.JSONDecodeError:
+        start = raw_text.find("{")
+        end = raw_text.rfind("}")
+        if start == -1 or end == -1 or end <= start:
+            logger.debug("Space agent response did not contain a JSON object: %s", raw_text)
+            return None
+        try:
+            parsed = json.loads(raw_text[start : end + 1])
+        except json.JSONDecodeError:
+            logger.warning("Space agent JSON extraction failed: %s", raw_text)
+            return None
+        return parsed if isinstance(parsed, dict) else None
+
+
+def _parse_tool_calls(payload: dict[str, Any]) -> list[SpaceAgentToolCall]:
+    if payload.get("mode") != "tool":
+        return []
+    raw_calls = payload.get("tool_calls")
+    if not isinstance(raw_calls, list):
+        return []
+
+    parsed_calls: list[SpaceAgentToolCall] = []
+    for raw_call in raw_calls[:SPACE_AGENT_MAX_TOOL_CALLS]:
+        if not isinstance(raw_call, dict):
+            continue
+        name = raw_call.get("name")
+        arguments = raw_call.get("arguments", {})
+        if name not in SPACE_AGENT_TOOL_NAMES or not isinstance(arguments, dict):
+            continue
+        parsed_calls.append(SpaceAgentToolCall(name=name, arguments=arguments))
+    return parsed_calls
+
+
+def execute_space_agent_tool(
+    tool_call: SpaceAgentToolCall, *, context: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Execute a built-in agent tool and return structured data."""
+    runtime = get_space_agent_runtime_info()
+    ctx = context or {}
+    _ensure_space_agent_not_cancelled(ctx)
+
+    if tool_call.name == "project_runtime":
+        return {
+            "model": runtime.model,
+            "dataset_repo": runtime.dataset_repo,
+            "model_repo": runtime.model_repo,
+            "space_repo": runtime.space_repo,
+            "huggingface_owner": runtime.huggingface_owner,
+            "has_publish_token": runtime.has_publish_token,
+            "capabilities": list(runtime.capabilities),
+            "command_presets": list(runtime.command_presets),
+        }
+    if tool_call.name == "model_dataset_playbook":
+        return {
+            "dataset_repo": runtime.dataset_repo,
+            "model_repo": runtime.model_repo,
+            "space_repo": runtime.space_repo,
+            **SPACE_AGENT_MODEL_DATASET_PLAYBOOK,
+        }
+    if tool_call.name == "training_presets":
+        return {"presets": list_training_base_models()}
+    if tool_call.name == "training_status":
+        training_status = ctx.get("training_status")
+        return (
+            training_status
+            if isinstance(training_status, dict)
+            else {
+                "running": False,
+                "message": "Training status nav pieejams šajā kontekstā.",
+            }
+        )
+    if tool_call.name == "sync_commands":
+        return {
+            "space_upload": f"MARIS_AGENT_SPACE_REPO={runtime.space_repo} bash ./huggingface/sync.sh upload-space",
+            "dataset_upload": "bash ./huggingface/sync.sh upload-dataset",
+            "model_upload": "bash ./huggingface/sync.sh upload-model",
+            "full_sync": "bash ./huggingface/sync.sh sync",
+        }
+    if tool_call.name == "workspace_command_catalog":
+        return {"presets": list(SPACE_AGENT_WORKSPACE_COMMAND_PRESETS)}
+    if tool_call.name == "browser_capabilities":
+        return get_browser_automation_capabilities().model_dump()
+    if tool_call.name == "persona_catalog":
+        return get_persona_catalog().model_dump()
+    if tool_call.name == "list_huggingface_repos":
+        return _list_huggingface_repos(tool_call.arguments)
+    if tool_call.name == "list_huggingface_repo_files":
+        return _list_huggingface_repo_files(tool_call.arguments)
+    if tool_call.name == "read_huggingface_repo_file":
+        return _read_huggingface_repo_file(tool_call.arguments)
+    if tool_call.name == "write_huggingface_repo_file":
+        return _write_huggingface_repo_file(tool_call.arguments, context=ctx)
+    if tool_call.name == "list_workspace":
+        return _list_workspace_entries(tool_call.arguments, context=ctx)
+    if tool_call.name == "read_workspace_file":
+        return _read_workspace_file(tool_call.arguments, context=ctx)
+    if tool_call.name == "write_workspace_file":
+        return _write_workspace_file(tool_call.arguments, context=ctx)
+    if tool_call.name == "run_workspace_command":
+        command_runner = ctx.get("workspace_command_runner")
+        if not callable(command_runner):
+            return {
+                "ok": False,
+                "error": "Workspace komandu izpilde nav pieejama šajā kontekstā.",
+                "error_type": "WorkspaceCommandUnavailable",
+            }
+        result = command_runner(tool_call.arguments)
+        return result if isinstance(result, dict) else {"ok": False, "error": "Nederīgs komandas rezultāts."}
+    raise ValueError(f"Unsupported tool call: {tool_call.name}")
+
+
+def _ensure_space_agent_not_cancelled(context: dict[str, Any] | None = None) -> None:
+    ctx = context or {}
+    cancel_checker = ctx.get("cancel_checker")
+    if callable(cancel_checker):
+        cancel_checker()
+
+
+def _get_hf_api_client() -> Any:
+    try:
+        from huggingface_hub import HfApi  # type: ignore
+    except ImportError as exc:  # pragma: no cover - environment-specific
+        raise RuntimeError("Hugging Face API klients nav pieejams.") from exc
+    return HfApi(token=get_env_any("MARIS_REPO_TOKEN", "MARIS_TOKEN", "HF_TOKEN"))
+
+
+def _download_hf_repo_file(*, repo_id: str, repo_type: str, path_in_repo: str) -> str:
+    try:
+        from huggingface_hub import hf_hub_download  # type: ignore
+    except ImportError as exc:  # pragma: no cover - environment-specific
+        raise RuntimeError("Hugging Face download helperis nav pieejams.") from exc
+    return str(
+        hf_hub_download(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            filename=path_in_repo,
+            token=get_env_any("MARIS_REPO_TOKEN", "MARIS_TOKEN", "HF_TOKEN"),
+        )
+    )
+
+
+def _validate_hf_repo_type(value: Any, *, allow_all: bool = False) -> str:
+    normalized = str(value or "").strip().lower() or ("all" if allow_all else "model")
+    allowed = {"model", "dataset", "space"}
+    if allow_all:
+        allowed.add("all")
+    if normalized not in allowed:
+        raise ValueError(f"repo_type jābūt vienam no: {', '.join(sorted(allowed))}.")
+    return normalized
+
+
+def _validate_hf_repo_id(value: Any) -> str:
+    normalized = str(value or "").strip()
+    if not SPACE_AGENT_MODEL_ID_RE.fullmatch(normalized):
+        raise ValueError("repo_id jābūt owner/name formātā.")
+    return normalized
+
+
+def _validate_owned_hf_repo_id(repo_id: str) -> str:
+    allowed_owner = _get_huggingface_owner()
+    owner = repo_id.split("/", 1)[0]
+    if owner != allowed_owner:
+        raise ValueError("Aģents drīkst rakstīt tikai savā konfigurētajā Hugging Face owner telpā.")
+    return repo_id
+
+
+def _normalize_hf_repo_path(value: Any) -> str:
+    raw_path = str(value or "").strip().strip("/")
+    if not raw_path:
+        raise ValueError("Jānorāda faila ceļš repozitorijā.")
+    if ".." in Path(raw_path).parts:
+        raise ValueError("Faila ceļš nedrīkst iziet ārpus repozitorija.")
+    return raw_path
+
+
+def _repo_entry(repo_type: str, item: Any) -> dict[str, Any]:
+    repo_id = (
+        getattr(item, "id", None)
+        or getattr(item, "repo_id", None)
+        or getattr(item, "modelId", None)
+        or getattr(item, "name", None)
+        or ""
+    )
+    return {
+        "id": str(repo_id),
+        "repo_type": repo_type,
+        "private": bool(getattr(item, "private", False)),
+        "sha": getattr(item, "sha", None),
+        "last_modified": (
+            getattr(item, "last_modified", None).isoformat()
+            if getattr(item, "last_modified", None) is not None
+            else None
+        ),
+    }
+
+
+def _list_huggingface_repos(arguments: dict[str, Any]) -> dict[str, Any]:
+    repo_type = _validate_hf_repo_type(arguments.get("repo_type"), allow_all=True)
+    search = str(arguments.get("search", "") or "").strip() or None
+    raw_limit = arguments.get("limit", 12)
+    try:
+        limit = max(1, min(int(raw_limit), 30))
+    except (TypeError, ValueError) as exc:
+        raise ValueError("limit jābūt skaitlim no 1 līdz 30.") from exc
+
+    owner = _get_huggingface_owner()
+    api = _get_hf_api_client()
+    entries: list[dict[str, Any]] = []
+
+    if repo_type in {"all", "model"}:
+        entries.extend(
+            _repo_entry("model", item)
+            for item in api.list_models(author=owner, search=search, limit=limit)
+        )
+    if repo_type in {"all", "dataset"}:
+        entries.extend(
+            _repo_entry("dataset", item)
+            for item in api.list_datasets(author=owner, search=search, limit=limit)
+        )
+    if repo_type in {"all", "space"}:
+        list_spaces = getattr(api, "list_spaces", None)
+        if callable(list_spaces):
+            entries.extend(
+                _repo_entry("space", item)
+                for item in list_spaces(author=owner, search=search, limit=limit)
+            )
+
+    return {
+        "owner": owner,
+        "repo_type": repo_type,
+        "entries": entries[
+            : (limit * SPACE_AGENT_HF_REPO_TYPE_COUNT if repo_type == "all" else limit)
+        ],
+    }
+
+
+def _list_huggingface_repo_files(arguments: dict[str, Any]) -> dict[str, Any]:
+    repo_id = _validate_hf_repo_id(arguments.get("repo_id"))
+    repo_type = _validate_hf_repo_type(arguments.get("repo_type"))
+    api = _get_hf_api_client()
+    files = sorted(api.list_repo_files(repo_id=repo_id, repo_type=repo_type))
+    return {
+        "repo_id": repo_id,
+        "repo_type": repo_type,
+        "entries": files[:SPACE_AGENT_MAX_DIRECTORY_ENTRIES],
+        "truncated": len(files) > SPACE_AGENT_MAX_DIRECTORY_ENTRIES,
+    }
+
+
+def _read_huggingface_repo_file(arguments: dict[str, Any]) -> dict[str, Any]:
+    repo_id = _validate_hf_repo_id(arguments.get("repo_id"))
+    repo_type = _validate_hf_repo_type(arguments.get("repo_type"))
+    path_in_repo = _normalize_hf_repo_path(arguments.get("path"))
+    local_path = Path(
+        _download_hf_repo_file(repo_id=repo_id, repo_type=repo_type, path_in_repo=path_in_repo)
+    )
+    raw_content = local_path.read_bytes()
+    truncated = len(raw_content) > SPACE_AGENT_MAX_FILE_BYTES
+    try:
+        content = raw_content[:SPACE_AGENT_MAX_FILE_BYTES].decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise ValueError("Pieprasītais HF fails nav UTF-8 teksta fails.") from exc
+    return {
+        "repo_id": repo_id,
+        "repo_type": repo_type,
+        "path": path_in_repo,
+        "content": content,
+        "encoding": "utf-8",
+        "truncated": truncated,
+        "size_bytes": len(raw_content),
+    }
+
+
+def _write_huggingface_repo_file(
+    arguments: dict[str, Any], *, context: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    repo_id = _validate_owned_hf_repo_id(_validate_hf_repo_id(arguments.get("repo_id")))
+    repo_type = _validate_hf_repo_type(arguments.get("repo_type"))
+    path_in_repo = _normalize_hf_repo_path(arguments.get("path"))
+    content = arguments.get("content")
+    if not isinstance(content, str):
+        raise ValueError("Rakstāmajam HF failam jāsaņem teksta saturs laukā 'content'.")
+    encoded = content.encode("utf-8")
+    if len(encoded) > SPACE_AGENT_MAX_FILE_BYTES:
+        raise ValueError("Saturs ir pārāk liels vienam HF write pieprasījumam.")
+    commit_message = (
+        str(arguments.get("commit_message", "") or "").strip() or f"Maris AI update {path_in_repo}"
+    )
+    previous_content = _try_read_existing_hf_repo_text(
+        repo_id=repo_id, repo_type=repo_type, path_in_repo=path_in_repo
+    )
+    operation = "create" if previous_content is None else "update"
+    diff = _build_text_diff(path=path_in_repo, previous=previous_content, current=content)
+    ctx = context or {}
+    stage_hf_write = ctx.get("stage_hf_write")
+    if ctx.get("require_publish_approval") and callable(stage_hf_write):
+        staged = stage_hf_write(
+            {
+                "repo_id": repo_id,
+                "repo_type": repo_type,
+                "path": path_in_repo,
+                "content": content,
+                "commit_message": commit_message,
+                "size_bytes": len(encoded),
+                "operation": operation,
+                "diff": diff,
+                "task_mode": ctx.get("task_mode", SPACE_AGENT_DEFAULT_TASK_MODE),
+            }
+        )
+        return {
+            "repo_id": repo_id,
+            "repo_type": repo_type,
+            "path": path_in_repo,
+            "size_bytes": len(encoded),
+            "commit_message": commit_message,
+            "saved": False,
+            "staged": True,
+            "requires_approval": True,
+            "operation": operation,
+            "diff": diff,
+            **(staged if isinstance(staged, dict) else {}),
+        }
+    return {
+        **save_huggingface_repo_text_file(
+            repo_id=repo_id,
+            repo_type=repo_type,
+            path_in_repo=path_in_repo,
+            content=content,
+            commit_message=commit_message,
+        ),
+        "operation": operation,
+        "diff": diff,
+    }
+
+
+def _workspace_root_from_context(context: dict[str, Any]) -> Path:
+    root_value = context.get("workspace_root")
+    if not isinstance(root_value, str) or not root_value.strip():
+        raise ValueError("Workspace root nav pieejams šajā kontekstā.")
+    workspace_root = Path(root_value).expanduser().resolve()
+    if not workspace_root.exists() or not workspace_root.is_dir():
+        raise ValueError("Workspace root nav pieejams vai nav direktorija.")
+    return workspace_root
+
+
+def _resolve_workspace_path(
+    arguments: dict[str, Any], *, context: dict[str, Any]
+) -> tuple[Path, Path]:
+    workspace_root = _workspace_root_from_context(context)
+    raw_path = str(arguments.get("path", ".")).strip() or "."
+    if ".." in Path(raw_path).parts:
+        raise ValueError("Ceļš atrodas ārpus atļautās Maris darba telpas.")
+    candidate = (workspace_root / raw_path).resolve()
+    try:
+        candidate.relative_to(workspace_root)
+    except ValueError as exc:
+        raise ValueError("Ceļš atrodas ārpus atļautās Maris darba telpas.") from exc
+    return workspace_root, candidate
+
+
+def _list_workspace_entries(
+    arguments: dict[str, Any], *, context: dict[str, Any]
+) -> dict[str, Any]:
+    workspace_root, target_path = _resolve_workspace_path(arguments, context=context)
+    if not target_path.exists():
+        raise ValueError("Pieprasītā direktorija neeksistē.")
+    if not target_path.is_dir():
+        raise ValueError("Pieprasītais ceļš nav direktorija.")
+
+    all_entries = sorted(
+        target_path.iterdir(), key=lambda item: (not item.is_dir(), item.name.lower())
+    )
+    entries: list[dict[str, Any]] = []
+    for entry in all_entries[:SPACE_AGENT_MAX_DIRECTORY_ENTRIES]:
+        relative_path = entry.relative_to(workspace_root).as_posix()
+        entries.append(
+            {
+                "path": relative_path,
+                "name": entry.name,
+                "type": "directory" if entry.is_dir() else "file",
+                "size_bytes": entry.stat().st_size if entry.is_file() else None,
+            }
+        )
+
+    return {
+        "workspace_root": str(workspace_root),
+        "path": target_path.relative_to(workspace_root).as_posix() or ".",
+        "entries": entries,
+        "truncated": len(all_entries) > SPACE_AGENT_MAX_DIRECTORY_ENTRIES,
+    }
+
+
+def _read_workspace_file(arguments: dict[str, Any], *, context: dict[str, Any]) -> dict[str, Any]:
+    workspace_root, target_path = _resolve_workspace_path(arguments, context=context)
+    if not target_path.exists():
+        raise ValueError("Pieprasītais fails neeksistē.")
+    if not target_path.is_file():
+        raise ValueError("Pieprasītais ceļš nav fails.")
+
+    raw_content = target_path.read_bytes()
+    truncated = len(raw_content) > SPACE_AGENT_MAX_FILE_BYTES
+    try:
+        content = raw_content[:SPACE_AGENT_MAX_FILE_BYTES].decode("utf-8")
+    except UnicodeDecodeError as exc:
+        raise ValueError("Pieprasītais fails nav UTF-8 teksta fails.") from exc
+    return {
+        "workspace_root": str(workspace_root),
+        "path": target_path.relative_to(workspace_root).as_posix(),
+        "content": content,
+        "encoding": "utf-8",
+        "truncated": truncated,
+        "size_bytes": len(raw_content),
+    }
+
+
+def _build_text_diff(*, path: str, previous: str | None, current: str) -> str:
+    before = [] if previous is None else previous.splitlines()
+    after = current.splitlines()
+    return "\n".join(
+        difflib.unified_diff(
+            before,
+            after,
+            fromfile=f"a/{path}",
+            tofile=f"b/{path}",
+            lineterm="",
+        )
+    )
+
+
+def _workspace_file_state(target_path: Path) -> tuple[str | None, str]:
+    if not target_path.exists():
+        return None, "create"
+    try:
+        previous = target_path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        previous = ""
+    return previous, "update"
+
+
+def _try_read_existing_hf_repo_text(*, repo_id: str, repo_type: str, path_in_repo: str) -> str | None:
+    try:
+        local_path = Path(
+            _download_hf_repo_file(repo_id=repo_id, repo_type=repo_type, path_in_repo=path_in_repo)
+        )
+    except (OSError, RuntimeError, ValueError, HfHubHTTPError) as exc:
+        logger.debug(
+            "Unable to read existing HF repo file %s/%s for diff preview: %s",
+            repo_id,
+            path_in_repo,
+            exc,
+        )
+        return None
+    try:
+        return local_path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return ""
+
+
+def save_huggingface_repo_text_file(
+    *,
+    repo_id: str,
+    repo_type: str,
+    path_in_repo: str,
+    content: str,
+    commit_message: str,
+) -> dict[str, Any]:
+    encoded = content.encode("utf-8")
+    api = _get_hf_api_client()
+    try:
+        api.upload_file(
+            path_or_fileobj=io.BytesIO(encoded),
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=commit_message,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("HF repo write failed for %s/%s: %s", repo_id, path_in_repo, exc)
+        detail = str(exc).strip()
+        raise RuntimeError(
+            f"Neizdevās saglabāt failu Hugging Face repozitorijā: {detail or type(exc).__name__}."
+        ) from exc
+    return {
+        "repo_id": repo_id,
+        "repo_type": repo_type,
+        "path": path_in_repo,
+        "size_bytes": len(encoded),
+        "commit_message": commit_message,
+        "saved": True,
+    }
+
+
+def delete_huggingface_repo_text_file(
+    *,
+    repo_id: str,
+    repo_type: str,
+    path_in_repo: str,
+    commit_message: str,
+) -> dict[str, Any]:
+    api = _get_hf_api_client()
+    try:
+        api.delete_file(
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=commit_message,
+        )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("HF repo delete failed for %s/%s: %s", repo_id, path_in_repo, exc)
+        detail = str(exc).strip()
+        raise RuntimeError(
+            f"Neizdevās dzēst failu Hugging Face repozitorijā: {detail or type(exc).__name__}."
+        ) from exc
+    return {
+        "repo_id": repo_id,
+        "repo_type": repo_type,
+        "path": path_in_repo,
+        "commit_message": commit_message,
+        "deleted": True,
+    }
+
+
+def _write_workspace_file(arguments: dict[str, Any], *, context: dict[str, Any]) -> dict[str, Any]:
+    workspace_root, target_path = _resolve_workspace_path(arguments, context=context)
+    content = arguments.get("content")
+    if not isinstance(content, str):
+        raise ValueError("Rakstāmajam failam jāsaņem teksta saturs laukā 'content'.")
+    encoded = content.encode("utf-8")
+    if len(encoded) > SPACE_AGENT_MAX_FILE_BYTES:
+        raise ValueError("Saturs ir pārāk liels vienam workspace write pieprasījumam.")
+
+    try:
+        target_path.parent.relative_to(workspace_root)
+    except ValueError as exc:
+        raise ValueError("Mērķa direktorija atrodas ārpus atļautās Maris darba telpas.") from exc
+    previous_content, operation = _workspace_file_state(target_path)
+    diff = _build_text_diff(
+        path=target_path.relative_to(workspace_root).as_posix(),
+        previous=previous_content,
+        current=content,
+    )
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    target_path.write_text(content, encoding="utf-8")
+    result = {
+        "workspace_root": str(workspace_root),
+        "path": target_path.relative_to(workspace_root).as_posix(),
+        "size_bytes": len(encoded),
+        "saved": True,
+        "operation": operation,
+        "diff": diff,
+    }
+    stage_workspace_write = context.get("stage_workspace_write")
+    if context.get("require_workspace_approval") and callable(stage_workspace_write):
+        staged = stage_workspace_write(
+            {
+                "path": result["path"],
+                "content": content,
+                "size_bytes": len(encoded),
+                "operation": operation,
+                "diff": diff,
+                "task_mode": context.get("task_mode", SPACE_AGENT_DEFAULT_TASK_MODE),
+                "draft_workspace_root": str(workspace_root),
+            }
+        )
+        return {
+            **result,
+            "saved": False,
+            "saved_to_draft": True,
+            "staged": True,
+            "requires_approval": True,
+            **(staged if isinstance(staged, dict) else {}),
+        }
+    return result
+
+
+def _tool_result_messages(
+    tool_calls: list[SpaceAgentToolCall],
+    *,
+    context: dict[str, Any] | None = None,
+    events: list[dict[str, Any]] | None = None,
+    event_callback: Callable[[dict[str, Any]], None] | None = None,
+) -> list[dict[str, str]]:
+    messages: list[dict[str, str]] = []
+    for tool_call in tool_calls:
+        _ensure_space_agent_not_cancelled(context)
+        _record_agent_event(
+            events,
+            event_callback,
+            {
+                "type": "tool_call",
+                "stage": "tooling",
+                "message": f"Izsaucu rīku {tool_call.name}.",
+                "tool_name": tool_call.name,
+                "arguments": tool_call.arguments,
+            },
+        )
+        try:
+            result = execute_space_agent_tool(tool_call, context=context)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Space agent tool %s failed: %s", tool_call.name, exc)
+            result = {
+                "ok": False,
+                "error": str(exc).strip() or type(exc).__name__,
+                "error_type": type(exc).__name__,
+                "tool_name": tool_call.name,
+            }
+            _record_agent_event(
+                events,
+                event_callback,
+                {
+                    "type": "tool_error",
+                    "stage": "tooling",
+                    "message": _tool_error_summary(tool_call, result),
+                    "tool_name": tool_call.name,
+                    "arguments": tool_call.arguments,
+                    "error": result,
+                },
+            )
+        else:
+            _record_agent_event(
+                events,
+                event_callback,
+                {
+                    "type": "tool_result",
+                    "stage": "tooling",
+                    "message": _tool_result_summary(tool_call, result),
+                    "tool_name": tool_call.name,
+                    "arguments": tool_call.arguments,
+                    "result": result,
+                },
+            )
+        messages.append(
+            {
+                "role": "assistant",
+                "content": json.dumps(
+                    {
+                        "tool_call": tool_call.model_dump(),
+                        "tool_result": result,
+                    },
+                    ensure_ascii=False,
+                ),
+            }
+        )
+    return messages
+
+
+def _record_agent_event(
+    events: list[dict[str, Any]] | None,
+    event_callback: Callable[[dict[str, Any]], None] | None,
+    event: dict[str, Any],
+) -> None:
+    if events is not None:
+        events.append(event)
+    if event_callback is not None:
+        event_callback(event)
+
+
+def _tool_result_summary(tool_call: SpaceAgentToolCall, result: dict[str, Any]) -> str:
+    if tool_call.name == "list_workspace":
+        path = str(result.get("path", "."))
+        entry_count = (
+            len(result.get("entries", [])) if isinstance(result.get("entries"), list) else 0
+        )
+        return f"Pārlūkoju direktoriju {path} un atradu {entry_count} ierakstus."
+    if tool_call.name == "read_workspace_file":
+        path = str(result.get("path", ""))
+        size_bytes = result.get("size_bytes")
+        size_label = f" ({size_bytes} B)" if isinstance(size_bytes, int) else ""
+        return f"Nolasīju failu {path}{size_label}."
+    if tool_call.name == "write_workspace_file":
+        if result.get("requires_approval"):
+            return "Sagatavoju workspace izmaiņas izolētā draftā un nodevu tās uz lietotāja apstiprinājumu."
+        path = str(result.get("path", ""))
+        size_bytes = result.get("size_bytes")
+        size_label = f" ({size_bytes} B)" if isinstance(size_bytes, int) else ""
+        operation = str(result.get("operation", "update"))
+        return f"Saglabāju {operation} failu {path}{size_label} darba telpā."
+    if tool_call.name == "run_workspace_command":
+        command_text = result.get("command_display") or result.get("command") or "komanda"
+        if result.get("ok") is False:
+            return f"Komandas izpilde neizdevās: {command_text}"
+        exit_code = result.get("exit_code")
+        return f"Palaidu validācijas komandu `{command_text}` ar exit kodu {exit_code}."
+    if tool_call.name == "training_status":
+        return "Savācu aktuālo Space treniņa statusu."
+    if tool_call.name == "model_dataset_playbook":
+        return "Savācu model/dataset uzlabošanas playbook ar HF agent principiem un komandām."
+    if tool_call.name == "training_presets":
+        return "Savācu pieejamos treniņa presetus."
+    if tool_call.name == "sync_commands":
+        return "Savācu sync un deploy komandas."
+    if tool_call.name == "workspace_command_catalog":
+        return "Savācu pilno validācijas un darba plūsmas command preset katalogu."
+    if tool_call.name == "browser_capabilities":
+        return "Savācu browser automation iespējas."
+    if tool_call.name == "persona_catalog":
+        return "Savācu pieejamo personu katalogu."
+    if tool_call.name == "list_huggingface_repos":
+        return "Savācu Hugging Face repozitoriju sarakstu."
+    if tool_call.name == "list_huggingface_repo_files":
+        return "Savācu Hugging Face repozitorija failu sarakstu."
+    if tool_call.name == "read_huggingface_repo_file":
+        return "Nolasīju Hugging Face repozitorija failu."
+    if tool_call.name == "write_huggingface_repo_file":
+        if result.get("requires_approval"):
+            return "Sagatavoju Hugging Face izmaiņas un nolieku tās uz lietotāja apstiprinājumu."
+        return "Saglabāju izmaiņas Hugging Face repozitorijā."
+    return "Savācu projekta runtime metadatus."
+
+
+def _tool_error_summary(tool_call: SpaceAgentToolCall, result: dict[str, Any]) -> str:
+    detail = str(result.get("error", "") or "").strip()
+    if detail:
+        return f"Rīks {tool_call.name} neizdevās: {detail}"
+    return f"Rīks {tool_call.name} neizdevās."
+
+
+def _final_response_from_json(raw_text: str) -> str:
+    payload = _extract_json_object(raw_text)
+    if payload is not None:
+        if payload.get("mode") == "final" and isinstance(payload.get("response"), str):
+            return payload["response"].strip()
+        if payload.get("mode") == "tool":
+            return ""
+        return raw_text.strip()
+    return raw_text.strip()
+
+
+def _assistant_json_message(raw_text: str) -> dict[str, str]:
+    return {"role": "assistant", "content": raw_text.strip()}
+
+
+def _collect_change_previews(events: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    previews: list[dict[str, Any]] = []
+    for event in events:
+        if event.get("type") != "tool_result":
+            continue
+        tool_name = str(event.get("tool_name", ""))
+        result = event.get("result")
+        if not isinstance(result, dict):
+            continue
+        if tool_name not in {"write_workspace_file", "write_huggingface_repo_file"}:
+            continue
+        path = str(result.get("path", "")).strip()
+        if not path:
+            continue
+        preview = {
+            "target": "workspace" if tool_name == "write_workspace_file" else "huggingface",
+            "path": path,
+            "operation": result.get("operation", "update"),
+            "diff": result.get("diff", ""),
+            "saved": bool(result.get("saved", False)),
+            "requires_approval": bool(result.get("requires_approval", False)),
+            "proposal_id": result.get("proposal_id"),
+            "repo_id": result.get("repo_id"),
+            "repo_type": result.get("repo_type"),
+        }
+        previews.append(preview)
+    return previews
+
+
+def _complete_with_client(
+    client: Any,
+    *,
+    models: tuple[str, ...],
+    messages: list[dict[str, str]],
+    max_tokens: int,
+    temperature: float,
+) -> tuple[str | None, str]:
+    last_error: Exception | None = None
+    for model in models:
+        try:
+            raw_response = client.chat_completion(
+                model=model,
+                messages=messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+        except StopIteration as exc:
+            logger.warning(
+                "Maris agent chat_completion raised StopIteration for model %s: %s",
+                model,
+                exc,
+            )
+            continue
+        # HF inference backends raise many provider-specific exception types here,
+        # so we treat non-fatal exceptions as retryable across the next model.
+        except (
+            OSError,
+            TypeError,
+            ValueError,
+            RuntimeError,
+            httpx.HTTPError,
+            HfHubHTTPError,
+        ) as exc:
+            last_error = exc
+            logger.warning("Maris agent inference failed for model %s: %s", model, exc)
+            continue
+        text = _response_text(raw_response)
+        if text:
+            return model, text
+        logger.warning("Maris agent returned an empty response for model %s", model)
+    if last_error is not None:
+        raise last_error
+    return None, ""
+
+
+def _complete_space_agent_response(
+    client: Any,
+    *,
+    models: tuple[str, ...],
+    messages: list[dict[str, str]],
+    max_tokens: int,
+    temperature: float,
+) -> tuple[str | None, str, bool]:
+    model_name, raw_response = _complete_with_client(
+        client,
+        models=models,
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=temperature,
+    )
+    if not raw_response:
+        active_model = model_name or next(iter(models), "")
+        raise RuntimeError(
+            f"Maris AI aģents nesaņēma derīgu atbildi no modeļa `{active_model}` "
+            "(tukša vai nederīga chat-completion atbilde)."
+        )
+    return model_name, raw_response, False
+
+
+def _build_space_agent_failure_message(
+    requested_model: str,
+    candidate_models: tuple[str, ...],
+    exc: Exception,
+) -> str:
+    resolved_model = next(iter(candidate_models), requested_model)
+    detail = str(exc).strip() or type(exc).__name__
+    return (
+        f"Maris AI aģents nevarēja pieslēgties modelim `{resolved_model}`. "
+        f"Pārbaudi modeļa pieejamību un inference konfigurāciju. Detalizācija: {detail}"
+    )
+
+
+def generate_space_agent_reply(
+    request: SpaceAgentChatRequest,
+    *,
+    client_factory: Any | None = None,
+    token: str | None = None,
+    tool_context: dict[str, Any] | None = None,
+    event_callback: Callable[[dict[str, Any]], None] | None = None,
+) -> SpaceAgentChatResponse:
+    """Generate an agent reply with optional tool-calling orchestration.
+
+    Tool selection runs with a capped low temperature to keep tool routing more
+    deterministic than the final user-facing answer.
+    """
+    runtime = get_space_agent_runtime_info()
+    requested_model = request.model or runtime.default_model
+    response_model = requested_model
+    candidate_models = resolve_space_agent_models(requested_model)
+    tooling_enabled = _should_enable_space_agent_tooling(request, requested_model)
+    events: list[dict[str, Any]] = []
+    tool_calls: list[SpaceAgentToolCall] = []
+    used_fallback = False
+
+    if client_factory is None:
+        try:
+            from huggingface_hub import InferenceClient  # type: ignore
+        except ImportError as exc:
+            raise RuntimeError("Maris AI inference klients nav pieejams.") from exc
+        client_factory = InferenceClient
+
+    try:
+        _ensure_space_agent_not_cancelled(tool_context)
+        client = create_hf_inference_client(client_factory, token=token)
+        _record_agent_event(
+            events,
+            event_callback,
+            {
+                "type": "status",
+                "stage": "queued",
+                "message": "Saņēmu uzdevumu un sāku analizēt pieprasījumu.",
+            },
+        )
+
+        if tooling_enabled:
+            tool_selection_messages = build_space_agent_messages(
+                request,
+                include_tooling_rules=True,
+                active_model=response_model,
+            )
+            executed_any_tools = False
+
+            for iteration in range(SPACE_AGENT_MAX_TOOL_ITERATIONS):
+                _ensure_space_agent_not_cancelled(tool_context)
+                _record_agent_event(
+                    events,
+                    event_callback,
+                    {
+                        "type": "status",
+                        "stage": "planning",
+                        "message": (
+                            "Plānoju nepieciešamos rīkus un darba soļus."
+                            if iteration == 0
+                            else "Izvērtēju iepriekšējo rīku rezultātus un plānoju nākamo soli."
+                        ),
+                    },
+                )
+                tool_selection_model, tool_selection_raw, tool_selection_fallback = (
+                    _complete_space_agent_response(
+                        client,
+                        models=candidate_models,
+                        messages=tool_selection_messages,
+                        max_tokens=min(request.max_tokens, 1024),
+                        temperature=min(request.temperature, 0.2),
+                    )
+                )
+                if tool_selection_model:
+                    used_fallback = used_fallback or tool_selection_fallback
+                    used_fallback = used_fallback or tool_selection_model != requested_model
+                    response_model = tool_selection_model
+                _ensure_space_agent_not_cancelled(tool_context)
+                tool_selection_payload = _extract_json_object(tool_selection_raw)
+                remaining_tool_budget = SPACE_AGENT_MAX_TOOL_CALLS - len(tool_calls)
+                current_tool_calls = (
+                    _parse_tool_calls(tool_selection_payload)[:remaining_tool_budget]
+                    if tool_selection_payload is not None and remaining_tool_budget > 0
+                    else []
+                )
+                final_response = _final_response_from_json(tool_selection_raw)
+                if not current_tool_calls:
+                    if final_response:
+                        _record_agent_event(
+                            events,
+                            event_callback,
+                            {
+                                "type": "final",
+                                "stage": "completed",
+                                "message": "Gala atbilde ir gatava.",
+                                "response": final_response,
+                            },
+                        )
+                        return SpaceAgentChatResponse(
+                            response=final_response,
+                            model=response_model,
+                            request_id=(tool_context or {}).get("request_id"),
+                            task_id=(tool_context or {}).get("task_id"),
+                            used_fallback=used_fallback,
+                            tool_calls=tool_calls,
+                            events=events,
+                            task_mode=request.task_mode,
+                            change_previews=_collect_change_previews(events),
+                        )
+                    break
+
+                tool_calls.extend(current_tool_calls)
+                executed_any_tools = True
+                _record_agent_event(
+                    events,
+                    event_callback,
+                    {
+                        "type": "status",
+                        "stage": "tooling",
+                        "message": f"Izvēlējos {len(current_tool_calls)} rīkus darba izpildei.",
+                    },
+                )
+                tool_selection_messages.append(_assistant_json_message(tool_selection_raw))
+                tool_selection_messages.extend(
+                    _tool_result_messages(
+                        current_tool_calls,
+                        context=tool_context,
+                        events=events,
+                        event_callback=event_callback,
+                    )
+                )
+            if executed_any_tools:
+                _record_agent_event(
+                    events,
+                    event_callback,
+                    {
+                        "type": "status",
+                        "stage": "final",
+                        "message": "Veidoju gala atbildi no savāktā konteksta.",
+                    },
+                )
+                final_messages = list(tool_selection_messages)
+                final_messages.append(
+                    {
+                        "role": "assistant",
+                        "content": (
+                            "Tagad pabeidz darbu. Ja viss nepieciešamais jau ir pārbaudīts un saglabāts, "
+                            'atbildi tikai ar JSON formātā {"mode":"final","response":"..."}.'
+                        ),
+                    }
+                )
+                final_model, final_raw, final_generation_fallback = _complete_space_agent_response(
+                    client,
+                    models=candidate_models,
+                    messages=final_messages,
+                    max_tokens=request.max_tokens,
+                    temperature=request.temperature,
+                )
+                if final_model:
+                    used_fallback = used_fallback or final_generation_fallback
+                    used_fallback = used_fallback or final_model != requested_model
+                    response_model = final_model
+                _ensure_space_agent_not_cancelled(tool_context)
+                final_response = _final_response_from_json(final_raw)
+                if final_response:
+                    _record_agent_event(
+                        events,
+                        event_callback,
+                        {
+                            "type": "final",
+                            "stage": "completed",
+                            "message": "Gala atbilde ir gatava.",
+                            "response": final_response,
+                        },
+                    )
+                    return SpaceAgentChatResponse(
+                        response=final_response,
+                        model=response_model,
+                        request_id=(tool_context or {}).get("request_id"),
+                        task_id=(tool_context or {}).get("task_id"),
+                        used_fallback=used_fallback,
+                        tool_calls=tool_calls,
+                        events=events,
+                        task_mode=request.task_mode,
+                        change_previews=_collect_change_previews(events),
+                    )
+            else:
+                _record_agent_event(
+                    events,
+                    event_callback,
+                    {
+                        "type": "status",
+                        "stage": "planning",
+                        "message": "Šim pieprasījumam pietiek ar tiešu atbildi bez papildu rīkiem.",
+                    },
+                )
+        elif request.tool_calling:
+            _record_agent_event(
+                events,
+                event_callback,
+                {
+                    "type": "status",
+                    "stage": "planning",
+                    "message": (
+                        "Aktīvais modelis ir teksta-first režīmā, tāpēc izmantoju vienkāršotu tiešās atbildes ceļu bez tool-calling."
+                    ),
+                },
+            )
+
+        _record_agent_event(
+            events,
+            event_callback,
+            {
+                "type": "status",
+                "stage": "final",
+                "message": "Veidoju gala atbildi.",
+            },
+        )
+        plain_model, plain_raw, plain_generation_fallback = _complete_space_agent_response(
+            client,
+            models=candidate_models,
+            messages=build_space_agent_messages(
+                request,
+                include_tooling_rules=tooling_enabled,
+                active_model=response_model,
+            ),
+            max_tokens=request.max_tokens,
+            temperature=request.temperature,
+        )
+        if plain_model:
+            used_fallback = used_fallback or plain_generation_fallback
+            used_fallback = used_fallback or plain_model != requested_model
+            response_model = plain_model
+        _ensure_space_agent_not_cancelled(tool_context)
+        final_response = _final_response_from_json(plain_raw)
+        if not final_response:
+            raise RuntimeError("Maris AI neatgrieza derīgu atbildi.")
+        _record_agent_event(
+            events,
+            event_callback,
+            {
+                "type": "final",
+                "stage": "completed",
+                "message": "Gala atbilde ir gatava.",
+                "response": final_response,
+            },
+        )
+        return SpaceAgentChatResponse(
+            response=final_response,
+            model=response_model,
+            request_id=(tool_context or {}).get("request_id"),
+            task_id=(tool_context or {}).get("task_id"),
+            used_fallback=used_fallback,
+            tool_calls=tool_calls if tooling_enabled else [],
+            events=events,
+            task_mode=request.task_mode,
+            change_previews=_collect_change_previews(events),
+        )
+    except SpaceAgentCancelledError:
+        raise
+    except (
+        AttributeError,
+        OSError,
+        TypeError,
+        ValueError,
+        RuntimeError,
+        httpx.HTTPError,
+        HfHubHTTPError,
+    ) as exc:
+        logger.warning("Maris agent inference failed: %s", exc)
+        raise RuntimeError(
+            _build_space_agent_failure_message(requested_model, candidate_models, exc)
+        ) from exc