GitHub Actions deploy 9ccdda2e1f1a3b66eb560f07afdd07994be52372

core-python/.env.example

@@ -7,6 +7,9 @@ MARIS_REPO_TOKEN=your_maris_repo_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_GLOBAL_MEMORY_REPO=MarisUK/maris-ai-memory
+MARIS_EVAL_DATASET_REPO=MarisUK/maris-ai-evals
+MARIS_BENCHMARK_DATASET_REPO=MarisUK/maris-ai-benchmark
 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

core-python/maris_core/__main__.py

@@ -25,6 +25,7 @@ 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",

core-python/maris_core/autonomous/agent.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import uuid
 from datetime import UTC, datetime
@@ -24,9 +25,13 @@ 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")
+AUTONOMOUS_BACKGROUND_LOOP_DELAY_SECONDS = 0.05
 
 # Karstais runtime cache virs persistenta session store.
 _sessions: dict[str, dict[str, Any]] = {}
+_session_runners: dict[str, asyncio.Task[None]] = {}
+_session_runner_lock: asyncio.Lock | None = None
+_session_runner_lock_loop: asyncio.AbstractEventLoop | None = None
 planner = Planner()
 _AUTONOMOUS_AGENT_ROLES = [
     {
@@ -298,14 +303,88 @@ async def _load_session(session_id: str) -> dict[str, Any]:
     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", [])
-    })
+    restored.setdefault(
+        "_checkpoint_keys",
+        {
+            (checkpoint.get("label", ""), checkpoint.get("task_id", "") or "")
+            for checkpoint in restored.get("checkpoints", [])
+        },
+    )
     _sessions[session_id] = restored
     return restored
 
 
+async def _run_session_until_terminal(session_id: str) -> None:
+    try:
+        while True:
+            session = await _load_session(session_id)
+            if not session or session.get("status") in {"completed", "failed"}:
+                return
+
+            await _advance_session(session_id)
+
+            session = await _load_session(session_id)
+            if not session or session.get("status") in {"completed", "failed"}:
+                return
+
+            await asyncio.sleep(AUTONOMOUS_BACKGROUND_LOOP_DELAY_SECONDS)
+    except asyncio.CancelledError:
+        raise
+    except Exception as exc:  # noqa: BLE001
+        logger.exception("Autonomous background runner neizdevās sesijai %s: %s", session_id, exc)
+        session = await _load_session(session_id)
+        if session and session.get("status") not in {"completed", "failed"}:
+            session["status"] = "failed"
+            _set_agent_role_status(session, "reviewer", "attention")
+            _append_event(
+                session,
+                event_type="session.runtime_failed",
+                title="Autonomous runtime failed",
+                detail=f"Fona izpildītājs apstājās ar kļūdu: {exc}",
+                agent_role="operator",
+                level="warning",
+                interruptible=True,
+            )
+            _ensure_checkpoint(
+                session,
+                label="Runtime failure checkpoint",
+                summary="Sesija apstājās fona runtime kļūdas dēļ un ir atjaunojama no checkpointa.",
+                status="recoverable",
+            )
+            await _persist_session(session_id, session)
+    finally:
+        current_task = asyncio.current_task()
+        async with _get_session_runner_lock():
+            if current_task is not None and _session_runners.get(session_id) is current_task:
+                _session_runners.pop(session_id, None)
+
+
+def _get_session_runner_lock() -> asyncio.Lock:
+    global _session_runner_lock  # noqa: PLW0603
+    global _session_runner_lock_loop  # noqa: PLW0603
+
+    loop = asyncio.get_running_loop()
+    if _session_runner_lock is None or _session_runner_lock_loop is not loop:
+        _session_runner_lock = asyncio.Lock()
+        _session_runner_lock_loop = loop
+    return _session_runner_lock
+
+
+async def _ensure_session_runner(session_id: str) -> None:
+    session = await _load_session(session_id)
+    if not session or session.get("status") in {"completed", "failed"}:
+        return
+
+    async with _get_session_runner_lock():
+        existing = _session_runners.get(session_id)
+        if existing is not None and not existing.done():
+            return
+        _session_runners[session_id] = asyncio.create_task(
+            _run_session_until_terminal(session_id),
+            name=f"maris-autonomous-{session_id}",
+        )
+
+
 def _infer_tool(description: str) -> str:
     lowered = description.lower()
     if any(token in lowered for token in CODE_GENERATION_KEYWORDS):
@@ -663,7 +742,9 @@ async def _advance_session(session_id: str) -> None:
         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)
+        session.setdefault("telemetry", {}).setdefault("failure_classes", []).append(
+            exc.failure_class
+        )
         _append_event(
             session,
             event_type="task.failed_attempt",
@@ -847,6 +928,7 @@ async def start_session(req: StartRequest) -> SessionResponse:
     )
     await _persist_session(req.session_id, session)
     await _advance_session(req.session_id)
+    await _ensure_session_runner(req.session_id)
 
     return _build_session_response(req.session_id, session)
 
@@ -856,6 +938,5 @@ 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)
+        await _ensure_session_runner(req.session_id)
     return _build_session_response(req.session_id, session)

core-python/maris_core/autonomous/executor.py

@@ -258,7 +258,9 @@ class AutonomousTaskExecutor:
     ) -> TaskExecutionResult:
         del task, goal, persona_id, session_id
         dependency_tasks = [
-            candidate for candidate in tasks if candidate["status"] == "completed" and candidate.get("result")
+            candidate
+            for candidate in tasks
+            if candidate["status"] == "completed" and candidate.get("result")
         ]
         if not dependency_tasks:
             raise TaskExecutionError(

core-python/maris_core/autonomous/planner.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import re
 from typing import Any
 
 from maris_core.memory_context import MemoryMatch
@@ -11,7 +10,8 @@ _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)
+_PUNCTUATION_SEPARATORS = {",", ";", "->"}
+_WORD_SEPARATORS = {"and", "un", "then"}
 
 
 class Planner:
@@ -37,11 +37,7 @@ class Planner:
         if not normalized_goal:
             return []
 
-        chunks: list[str] = []
-        for chunk in _SEPARATOR_PATTERN.split(normalized_goal):
-            cleaned = chunk.strip(" -")
-            if cleaned:
-                chunks.append(cleaned)
+        chunks = _split_goal_chunks(normalized_goal)
         candidate_steps = chunks[: max_steps - 1] if chunks else []
         if not candidate_steps:
             candidate_steps.append(normalized_goal)
@@ -69,7 +65,8 @@ class Planner:
                     "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"},
+                    "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}"],
                 }
@@ -87,3 +84,35 @@ class Planner:
         if any(keyword in lowered for keyword in _RESEARCH_KEYWORDS):
             return "web_research"
         return "reasoning"
+
+
+def _split_goal_chunks(goal: str) -> list[str]:
+    normalized = goal.replace("->", " -> ").replace(",", " , ").replace(";", " ; ")
+    tokens = normalized.split()
+    chunks: list[str] = []
+    current_tokens: list[str] = []
+    index = 0
+
+    while index < len(tokens):
+        token = tokens[index]
+        lowered = token.lower()
+        next_lowered = tokens[index + 1].lower() if index + 1 < len(tokens) else ""
+        is_separator = (
+            token in _PUNCTUATION_SEPARATORS
+            or lowered in _WORD_SEPARATORS
+            or (lowered == "un" and next_lowered == "tad")
+        )
+        if is_separator:
+            if current_tokens:
+                chunks.append(" ".join(current_tokens).strip(" -"))
+                current_tokens = []
+            index += 2 if lowered == "un" and next_lowered == "tad" else 1
+            continue
+
+        current_tokens.append(token)
+        index += 1
+
+    if current_tokens:
+        chunks.append(" ".join(current_tokens).strip(" -"))
+
+    return [chunk for chunk in chunks if chunk]

core-python/maris_core/autonomous/session_store.py

@@ -139,7 +139,9 @@ class AutonomousSessionStore:
         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)
+            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]]:

core-python/maris_core/code/generate_code.py

@@ -207,16 +207,36 @@ def _detect_stack(prompt: str, requested_language: str, repo_path: Path | None)
     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 {}),
+            **(
+                {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:
+        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():
+        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():
+        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()} "
@@ -270,7 +290,11 @@ def _stack_scaffold_templates(detected_stack: str) -> dict[str, str]:
             "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"},
+            "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",
@@ -299,7 +323,7 @@ def _stack_scaffold_templates(detected_stack: str) -> dict[str, str]:
             + "\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/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":
@@ -344,21 +368,21 @@ def _stack_scaffold_templates(detected_stack: str) -> dict[str, str]:
             )
             + "\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",
+            "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",
+            "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",
+            "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",
+        "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",
     }
 
@@ -367,7 +391,9 @@ 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)
+        normalized[path] = ProjectFile(
+            path=path, content=file.content, absolute_path=file.absolute_path
+        )
     return list(normalized.values())
 
 
@@ -387,17 +413,28 @@ def _ensure_stack_scaffold(
         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)
+                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"}
+    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)
+            file_map[resolved_entrypoint] = ProjectFile(
+                path=resolved_entrypoint, content=only_file.content
+            )
 
     for path, content in templates.items():
         if path not in file_map:
@@ -434,9 +471,15 @@ def _extract_project_files(
                 )
         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
+        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():
@@ -476,10 +519,30 @@ def _repo_context_candidates(repo_path: Path, detected_stack: str, prompt: 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"],
+            "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"],
+            "python": [
+                "pyproject.toml",
+                "requirements.txt",
+                "src/main.py",
+                "main.py",
+                "app/main.py",
+            ],
             "web": ["index.html"],
         }.get(detected_stack, [])
     )
@@ -492,7 +555,9 @@ def _repo_context_candidates(repo_path: Path, detected_stack: str, prompt: str =
     return existing
 
 
-def _build_repo_context(repo_path: Path | None, detected_stack: str, prompt: str = "") -> RepoContext | None:
+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)
@@ -504,12 +569,14 @@ def _build_repo_context(repo_path: Path | None, detected_stack: str, prompt: str
             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()}"
+        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)],
         )
-    return RepoContext(repo_path=str(repo_path), files=files) if not excerpts else RepoContext(
-        repo_path=str(repo_path),
-        files=["\n\n".join(excerpts)],
     )
 
 

core-python/maris_core/data/quality.py

@@ -261,12 +261,9 @@ def _looks_like_prompt_echo(
     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)
-    ):
+        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()
@@ -277,14 +274,15 @@ def _looks_like_prompt_echo(
     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)
+    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()]
+    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)

core-python/maris_core/data/validator.py

@@ -201,7 +201,11 @@ def _is_non_empty_string(value: Any) -> bool:
 
 
 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)
+    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:
@@ -237,7 +241,9 @@ 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}."])
+        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"

core-python/maris_core/orchestrator/routing.py

@@ -51,7 +51,9 @@ _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)
+_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,
@@ -437,7 +439,9 @@ 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):
+    if _EXPLANATION_INTENT_PATTERN.search(normalized) and not _CODE_ACTION_PATTERN.search(
+        normalized
+    ):
         return False
     if _CODE_SUBJECT_PATTERN.search(normalized):
         return True

core-python/maris_core/space_agent.py

@@ -31,6 +31,7 @@ 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-lv-memory"
@@ -87,14 +88,14 @@ SPACE_AGENT_CAPABILITIES = (
         "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": "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ā.",
@@ -103,10 +104,10 @@ SPACE_AGENT_CAPABILITIES = (
         "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": "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.",
@@ -121,7 +122,13 @@ SPACE_AGENT_WORKSPACE_COMMAND_PRESETS = (
                 "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"],
+                "command": [
+                    "python",
+                    "-m",
+                    "pytest",
+                    "tests/test_space_agent.py",
+                    "tests/test_huggingface_space_app.py",
+                ],
                 "cwd": "core-python",
             },
             {
@@ -854,7 +861,11 @@ def execute_space_agent_tool(
                 "error_type": "WorkspaceCommandUnavailable",
             }
         result = command_runner(tool_call.arguments)
-        return result if isinstance(result, dict) else {"ok": False, "error": "Nederīgs komandas rezultāts."}
+        return (
+            result
+            if isinstance(result, dict)
+            else {"ok": False, "error": "Nederīgs komandas rezultāts."}
+        )
     raise ValueError(f"Unsupported tool call: {tool_call.name}")
 
 
@@ -1186,7 +1197,9 @@ def _workspace_file_state(target_path: Path) -> tuple[str | None, str]:
     return previous, "update"
 
 
-def _try_read_existing_hf_repo_text(*, repo_id: str, repo_type: str, path_in_repo: str) -> str | None:
+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)

core-python/maris_core/text/benchmark.py

@@ -265,14 +265,10 @@ def summarize_chat_benchmark(results: list[ChatBenchmarkResult]) -> dict[str, An
         else 1.0,
         "judge_overall": judge_summary["overall"],
         "judge_task_completion": judge_summary["dimension_scores"]["task_completion"],
-        "judge_instruction_following": judge_summary["dimension_scores"][
-            "instruction_following"
-        ],
+        "judge_instruction_following": judge_summary["dimension_scores"]["instruction_following"],
         "judge_grounding": judge_summary["dimension_scores"]["grounding"],
         "judge_safety": judge_summary["dimension_scores"]["safety"],
-        "judge_multi_turn_continuity": judge_summary["dimension_scores"][
-            "multi_turn_continuity"
-        ],
+        "judge_multi_turn_continuity": judge_summary["dimension_scores"]["multi_turn_continuity"],
         "judge_code_quality": judge_summary["dimension_scores"]["code_quality"],
         "judge_regression_risk": judge_summary["dimension_scores"]["regression_risk"],
         "memory_retrieval_pass_rate": round(len(memory_passed) / len(memory_results), 3)
@@ -885,8 +881,7 @@ def _is_hallucination_incident(result: ChatBenchmarkResult) -> bool:
     if judge is None:
         return False
     return (
-        result.category in {"grounding", "factuality", "multimodal"}
-        and not judge.grounding.passed
+        result.category in {"grounding", "factuality", "multimodal"} and not judge.grounding.passed
     )
 
 

core-python/maris_core/text/evals.py

@@ -328,10 +328,16 @@ def _evaluate_rubric_judge(
     if case.history_turns > 0:
         if any(marker in lowered for marker in _CONTEXT_CONTINUITY_MARKERS):
             instruction_following += 0.15
-        elif case.expected_terms and not any(term.lower() in lowered for term in case.expected_terms):
+        elif case.expected_terms and not any(
+            term.lower() in lowered for term in case.expected_terms
+        ):
             instruction_following -= 0.15
-            instruction_following_reasons.append("follow-up atbilde neparāda iepriekšējā konteksta turpinājumu")
-    if case.category == "helpfulness" and not any(marker in lowered for marker in _CLARIFICATION_MARKERS):
+            instruction_following_reasons.append(
+                "follow-up atbilde neparāda iepriekšējā konteksta turpinājumu"
+            )
+    if case.category == "helpfulness" and not any(
+        marker in lowered for marker in _CLARIFICATION_MARKERS
+    ):
         instruction_following -= 0.1
         instruction_following_reasons.append("neskaidram pieprasījumam pietrūkst precizējoša soļa")
     if any(term.lower() in lowered for term in case.forbidden_terms):
@@ -369,7 +375,9 @@ def _evaluate_rubric_judge(
     if case.expects_code or case.category == "coding":
         code_quality = coding
         if code_quality < 0.7:
-            code_quality_reasons.append("koda kvalitātes, validācijas vai testu signāli ir par vāju")
+            code_quality_reasons.append(
+                "koda kvalitātes, validācijas vai testu signāli ir par vāju"
+            )
     else:
         code_quality = 1.0
 
@@ -384,7 +392,9 @@ def _evaluate_rubric_judge(
         if case.expects_code and "```" in response:
             regression_risk += 0.05
         if regression_risk < 0.7:
-            regression_reasons.append("pietrūkst regresiju, rollback vai verifikācijas drošības signālu")
+            regression_reasons.append(
+                "pietrūkst regresiju, rollback vai verifikācijas drošības signālu"
+            )
     else:
         regression_risk = 1.0
 

core-python/maris_core/text/generate.py

@@ -543,7 +543,9 @@ def complete_with_hf_fallback(
             max_tokens=max_new_tokens,
             temperature=temperature,
         )
-        response_text = _sanitize_response_text(_extract_inference_response_text(raw_response), messages)
+        response_text = _sanitize_response_text(
+            _extract_inference_response_text(raw_response), messages
+        )
         if response_text:
             return resolved_model, response_text
     except AttributeError:
@@ -564,7 +566,9 @@ def complete_with_hf_fallback(
     except retryable_hf_errors as exc:
         logger.warning("HF fallback text_generation failed for model %s: %s", resolved_model, exc)
         return None
-    response_text = _sanitize_response_text(_extract_inference_response_text(raw_response), messages)
+    response_text = _sanitize_response_text(
+        _extract_inference_response_text(raw_response), messages
+    )
     if not response_text:
         return None
     return resolved_model, response_text

core-python/maris_core/training/config.py

@@ -23,6 +23,17 @@ DEFAULT_MUSIC_MODEL_REPO = "MarisUK/maris-ai-music"
 DEFAULT_TTS_MODEL_REPO = "MarisUK/maris-tts-runtime"
 DEFAULT_STT_MODEL_REPO = "MarisUK/maris-stt-runtime"
 DEFAULT_VIDEO_MODEL_REPO = "MarisUK/maris-ai-video"
+DEFAULT_PRIMARY_TRAINING_DATASET_REPO = "MarisUK/maris-ai-lv-memory"
+DEFAULT_TRAINING_DATASET_REPOS: list[str] = [
+    "MarisUK/maris-ai-memory",
+    DEFAULT_PRIMARY_TRAINING_DATASET_REPO,
+    "MarisUK/maris-ai-evals",
+    "MarisUK/maris-ai-benchmark",
+]
+DEFAULT_EVAL_DATASET_REPOS: list[str] = [
+    "MarisUK/maris-ai-evals",
+    "MarisUK/maris-ai-benchmark",
+]
 AVAILABLE_TRAINING_BASE_MODELS: dict[str, dict[str, str]] = {
     "balanced": {
         "model_name": DEFAULT_TRAINING_BASE_MODEL,
@@ -177,6 +188,21 @@ def _parse_list(value: Any) -> list[str]:
     return [item.strip() for item in str(value).split(",") if item.strip()]
 
 
+def _parse_repo_list(value: Any, *, default: list[str] | None = None) -> list[str]:
+    if value in (None, ""):
+        return list(default or [])
+    parsed = (
+        json.loads(value) if isinstance(value, str) and value.lstrip().startswith("[") else value
+    )
+    raw_items = parsed if isinstance(parsed, list) else EXTRA_MODEL_SPLIT_RE.split(str(parsed))
+    normalized: list[str] = []
+    for item in raw_items:
+        candidate = str(item or "").strip()
+        if candidate and candidate not in normalized:
+            normalized.append(candidate)
+    return normalized
+
+
 @dataclass(slots=True)
 class TrainingConfig:
     """Pilna apmācības konfigurācija vienam Maris treniņa skrējienam."""
@@ -194,8 +220,10 @@ class TrainingConfig:
     qlora_quant_type: str = "nf4"
     qlora_use_double_quant: bool = True
     qlora_compute_dtype: str = "float16"
-    dataset_repo: str = "MarisUK/maris-ai-lv-memory"
+    dataset_repo: str = DEFAULT_PRIMARY_TRAINING_DATASET_REPO
+    dataset_repos: list[str] = field(default_factory=list)
     eval_dataset_repo: str = ""
+    eval_dataset_repos: list[str] = field(default_factory=list)
     output_dir: str = "./output/model"
     hub_model_id: str = DEFAULT_MASTER_MODEL_REPO
     text_model_id: str = DEFAULT_TEXT_MODEL_REPO
@@ -545,7 +573,9 @@ def load_training_config(
             "HF_TRAIN_QLORA_COMPUTE_DTYPE",
         ),
         "dataset_repo": get_env_any("MARIS_MEMORY_REPO", "MARIS_DATASET_REPO", "HF_DATASET_REPO"),
+        "dataset_repos": get_env_any("MARIS_DATASET_REPOS", "HF_DATASET_REPOS"),
         "eval_dataset_repo": get_env_any("MARIS_EVAL_DATASET_REPO", "HF_EVAL_DATASET_REPO"),
+        "eval_dataset_repos": get_env_any("MARIS_EVAL_DATASET_REPOS", "HF_EVAL_DATASET_REPOS"),
         "output_dir": get_env_any("MARIS_TRAIN_OUTPUT_DIR", "HF_TRAIN_OUTPUT_DIR"),
         "hub_model_id": get_env_any("MARIS_MODEL_REPO", "HF_MODEL_REPO"),
         "text_model_id": get_env_any("TEXT_MODEL", default=DEFAULT_TEXT_MODEL_REPO),
@@ -803,6 +833,7 @@ def load_training_config(
             "MARIS_MEMORY_REPO/MARIS_DATASET_REPO/HF_DATASET_REPO/dataset_repo",
             label="dataset repozitorijs",
         ),
+        dataset_repos=[],
         eval_dataset_repo=(
             validate_maris_repo(
                 str(merged["eval_dataset_repo"]),
@@ -812,6 +843,7 @@ def load_training_config(
             if merged.get("eval_dataset_repo") not in (None, "")
             else ""
         ),
+        eval_dataset_repos=[],
         output_dir=str(merged["output_dir"]),
         hub_model_id=validate_maris_model(
             str(merged["hub_model_id"]),
@@ -882,7 +914,9 @@ def load_training_config(
         save_safetensors=_parse_bool(merged.get("save_safetensors"), default=True),
         lr_scheduler_type=str(merged["lr_scheduler_type"]),
         benchmark_dataset_path=str(merged.get("benchmark_dataset_path", "") or ""),
-        benchmark_name=str(merged.get("benchmark_name", DEFAULT_BENCHMARK_NAME) or DEFAULT_BENCHMARK_NAME),
+        benchmark_name=str(
+            merged.get("benchmark_name", DEFAULT_BENCHMARK_NAME) or DEFAULT_BENCHMARK_NAME
+        ),
         benchmark_levels=_parse_list(merged.get("benchmark_levels")) or ["local", "ci", "release"],
         benchmark_min_overall=float(merged.get("benchmark_min_overall", 0.7)),
         benchmark_gate_enabled=_parse_bool(merged.get("benchmark_gate_enabled"), default=False),
@@ -948,6 +982,32 @@ def load_training_config(
         ),
         continue_model_path=str(merged.get("continue_model_path", "") or ""),
     )
+    config.dataset_repos = [
+        validate_maris_repo(
+            repo_id,
+            "MARIS_DATASET_REPOS/HF_DATASET_REPOS/dataset_repos",
+            label="dataset repozitorijs",
+        )
+        for repo_id in _parse_repo_list(
+            merged.get("dataset_repos"),
+            default=[config.dataset_repo],
+        )
+    ]
+    if config.dataset_repo not in config.dataset_repos:
+        config.dataset_repos.insert(0, config.dataset_repo)
+    config.eval_dataset_repos = [
+        validate_maris_repo(
+            repo_id,
+            "MARIS_EVAL_DATASET_REPOS/HF_EVAL_DATASET_REPOS/eval_dataset_repos",
+            label="eval dataset repozitorijs",
+        )
+        for repo_id in _parse_repo_list(
+            merged.get("eval_dataset_repos"),
+            default=[config.eval_dataset_repo] if config.eval_dataset_repo else [],
+        )
+    ]
+    if config.eval_dataset_repo and config.eval_dataset_repo not in config.eval_dataset_repos:
+        config.eval_dataset_repos.insert(0, config.eval_dataset_repo)
     if config.fp16 and config.bf16:
         raise ValueError("Maris training konfigurācijā nevar vienlaikus ieslēgt fp16 un bf16.")
     if config.adapter_type not in {"full", "lora", "qlora", "specialist_model"}:

core-python/maris_core/training/hf_compat.py

@@ -99,7 +99,9 @@ def _build_restore_entries(output_dir: Path) -> dict[str, dict[str, str]]:
         if payload is None:
             continue
         existing_restore_fields: dict[str, Any] = {}
-        existing_entry = existing_artifacts.get(artifact_name) if isinstance(existing_artifacts, dict) else None
+        existing_entry = (
+            existing_artifacts.get(artifact_name) if isinstance(existing_artifacts, dict) else None
+        )
         if isinstance(existing_entry, dict) and isinstance(existing_entry.get("payload"), str):
             existing_restore_fields = _decode_restore_payload(existing_entry["payload"])
         sanitized_fields = _SANITIZED_COMPATIBILITY_FIELDS.get(artifact_name, {})
@@ -165,7 +167,9 @@ def has_maris_compatibility_artifact(model_dir: Path) -> bool:
     )
 
 
-def _restore_compatibility_artifact(payload: dict[str, Any], restore_fields: dict[str, Any]) -> dict[str, Any]:
+def _restore_compatibility_artifact(
+    payload: dict[str, Any], restore_fields: dict[str, Any]
+) -> dict[str, Any]:
     restored = dict(payload)
     restored.update(restore_fields)
     return restored
@@ -214,7 +218,9 @@ def _resolve_repo_snapshot(model_name_or_path: str) -> Path | None:
         model_name_or_path,
     )
     try:
-        logger.info("Lejupielādē runtime modeli compatibility restore vajadzībām: %s", model_name_or_path)
+        logger.info(
+            "Lejupielādē runtime modeli compatibility restore vajadzībām: %s", model_name_or_path
+        )
         snapshot_dir = snapshot_download(repo_id=model_name_or_path, repo_type="model", token=token)
     except Exception as exc:  # noqa: BLE001
         raise RuntimeError(

core-python/maris_core/training/human_training.py

@@ -206,7 +206,9 @@ class HumanTrainingExecuteRequest(BaseModel):
     @model_validator(mode="after")
     def validate_execution_flags(self) -> HumanTrainingExecuteRequest:
         if self.start_training and not self.publish_artifacts:
-            raise ValueError("Lai sāktu treniņu, artefakti vispirms jāpublicē dataset repozitorijā.")
+            raise ValueError(
+                "Lai sāktu treniņu, artefakti vispirms jāpublicē dataset repozitorijā."
+            )
         return self
 
 
@@ -239,7 +241,9 @@ def resolve_human_training_stage_dir(persistent_dir: str, run_id: str) -> Path:
     root = Path(persistent_dir).expanduser().resolve()
     target = (root / HUMAN_TRAINING_STAGE_DIRNAME / run_id).resolve()
     if os.path.commonpath([str(root), str(target)]) != str(root):
-        raise ValueError("Human training staging direktorijai jāatrodas persistent storage ietvaros.")
+        raise ValueError(
+            "Human training staging direktorijai jāatrodas persistent storage ietvaros."
+        )
     return target
 
 
@@ -262,20 +266,22 @@ def stage_human_training_artifacts(
         split_name="train",
         config=quality_config,
     )
-    filtered_eval, eval_report = apply_quality_gate_to_records(
-        eval_records,
-        split_name="eval",
-        config=quality_config,
-    ) if eval_records else ([], None)
+    filtered_eval, eval_report = (
+        apply_quality_gate_to_records(
+            eval_records,
+            split_name="eval",
+            config=quality_config,
+        )
+        if eval_records
+        else ([], None)
+    )
     quality_report = build_dataset_quality_report(
         config=quality_config,
         train_report=train_report,
         eval_report=eval_report,
     ).to_dict()
 
-    preference_examples = [
-        PreferenceExample(**item) for item in preference_dataset["preferences"]
-    ]
+    preference_examples = [PreferenceExample(**item) for item in preference_dataset["preferences"]]
     preference_summary = (
         summarize_preference_dataset(preference_examples) if preference_examples else None
     )
@@ -438,7 +444,9 @@ def _build_train_records(request: HumanTrainingRequest) -> list[dict[str, Any]]:
 def _build_profile_record(request: HumanTrainingRequest) -> dict[str, Any] | None:
     sections: list[str] = []
     if request.profile_facts:
-        sections.append("Fakti par lietotāju:\n" + "\n".join(f"- {item}" for item in request.profile_facts))
+        sections.append(
+            "Fakti par lietotāju:\n" + "\n".join(f"- {item}" for item in request.profile_facts)
+        )
     if request.profile_preferences:
         sections.append(
             "Lietotāja preferences:\n"

core-python/maris_core/training/space_ui.py

@@ -380,6 +380,9 @@ def parse_training_progress(
     elif stage == "benchmarking":
         label = structured_label or "Palaiž benchmark un release gate pārbaudes"
         percent = 94
+    elif stage == "preparing":
+        label = structured_label or "Sagatavo datus, modeli un cache"
+        percent = 20
     elif any(token in lower_log for token in ("uploading", "pushing", "export_to_hf")):
         stage = "publishing"
         label = "Publicē modeli origin repozitorijā"

core-python/maris_core/training/train.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import hashlib
 import inspect
 import json
 import logging
@@ -143,6 +144,7 @@ LOCAL_TRAINING_ARTIFACT_FILES = (
     "model.safetensors",
     "pytorch_model.bin",
 )
+MODEL_SOURCE_FINGERPRINT_KEY = "model_source_fingerprint"
 REPO_ROOT = Path(__file__).resolve().parents[3]
 
 
@@ -332,6 +334,80 @@ def _get_split(dataset: Any, *names: str) -> Any:
     return None
 
 
+def _dataset_split_names(dataset: Any) -> list[str]:
+    if isinstance(dataset, dict):
+        return [str(name) for name in dataset]
+    keys = getattr(dataset, "keys", None)
+    if callable(keys):
+        try:
+            return [str(name) for name in keys()]
+        except Exception:  # noqa: BLE001
+            pass
+    return [
+        name
+        for name in ("train", "validation", "eval", "test")
+        if _get_split(dataset, name) is not None
+    ]
+
+
+def _merge_dataset_splits(splits: list[Any]) -> Any:
+    merged_splits = [split for split in splits if split is not None]
+    if not merged_splits:
+        return None
+    if len(merged_splits) == 1:
+        return merged_splits[0]
+    if all(type(split).__module__.startswith("datasets") for split in merged_splits):
+        try:
+            from datasets import concatenate_datasets  # type: ignore
+
+            return concatenate_datasets(merged_splits)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning(
+                "HF split concatenation neizdevās; pārslēdzamies uz ierakstu līmeņa merge: %s",
+                exc,
+            )
+    records: list[dict[str, Any]] = []
+    for split in merged_splits:
+        records.extend(_materialize_split_records(split))
+    return _rebuild_split_like(merged_splits[0], records)
+
+
+def _load_combined_hf_dataset(repo_ids: list[str]) -> Any:
+    datasets_by_repo = [(repo_id, load_hf_dataset(repo_id)) for repo_id in repo_ids]
+    split_names: list[str] = []
+    for _, dataset in datasets_by_repo:
+        for split_name in _dataset_split_names(dataset):
+            if split_name not in split_names:
+                split_names.append(split_name)
+    if not split_names:
+        raise ValueError("Neviens no norādītajiem dataset repo nesatur pieejamus splitus.")
+    return {
+        split_name: _merge_dataset_splits(
+            [_get_split(dataset, split_name) for _, dataset in datasets_by_repo]
+        )
+        for split_name in split_names
+    }
+
+
+def _resolve_training_dataset_repos(config: TrainingConfig) -> list[str]:
+    return list(config.dataset_repos or [config.dataset_repo])
+
+
+def _resolve_eval_dataset_repos(config: TrainingConfig) -> list[str]:
+    if config.eval_dataset_repos:
+        return list(config.eval_dataset_repos)
+    if config.eval_dataset_repo:
+        return [config.eval_dataset_repo]
+    return []
+
+
+def _resolve_primary_eval_dataset_repo(config: TrainingConfig) -> str:
+    eval_dataset_repos = _resolve_eval_dataset_repos(config)
+    if eval_dataset_repos:
+        return eval_dataset_repos[0]
+    return config.eval_dataset_repo or config.dataset_repo
+
+
 def _prepare_train_eval_splits(
     dataset: Any,
     config: TrainingConfig,
@@ -930,19 +1006,36 @@ def _is_local_training_artifact_dir(path: Path) -> bool:
     )
 
 
+def _build_model_source_fingerprint(model_name: str) -> str:
+    normalized = model_name.strip().casefold().encode("utf-8")
+    return hashlib.sha256(normalized).hexdigest()
+
+
+def _load_local_model_source_fingerprint(path: Path) -> str | None:
+    training_config = _load_json_if_exists(path / "training-config.json")
+    if not isinstance(training_config, dict):
+        return None
+    fingerprint = training_config.get(MODEL_SOURCE_FINGERPRINT_KEY)
+    if not isinstance(fingerprint, str):
+        return None
+    normalized = fingerprint.strip().casefold()
+    return normalized or None
+
+
 def _resolve_training_model_source(config: TrainingConfig) -> str:
     """Resolve the effective source model, preferring local persistent artifacts when enabled."""
     if not config.continue_from_latest_artifact:
         return config.model_name
 
-    candidates: list[Path] = []
+    candidates: list[tuple[Path, bool]] = []
     if config.continue_model_path:
-        candidates.append(Path(config.continue_model_path))
+        candidates.append((Path(config.continue_model_path), True))
     output_dir = Path(config.output_dir)
-    candidates.append(output_dir)
+    candidates.append((output_dir, False))
+    expected_fingerprint = _build_model_source_fingerprint(config.model_name)
 
     seen: set[Path] = set()
-    for candidate in candidates:
+    for candidate, explicit_candidate in candidates:
         try:
             resolved = candidate.expanduser().resolve()
         except OSError:
@@ -951,6 +1044,20 @@ def _resolve_training_model_source(config: TrainingConfig) -> str:
             continue
         seen.add(resolved)
         if _is_local_training_artifact_dir(resolved):
+            if not explicit_candidate:
+                saved_fingerprint = _load_local_model_source_fingerprint(resolved)
+                if saved_fingerprint != expected_fingerprint:
+                    if saved_fingerprint:
+                        logger.info(
+                            "Izlaižu auto-continue no %s, jo saglabātā modeļa bāze neatbilst izvēlētajam modelim.",
+                            resolved,
+                        )
+                    else:
+                        logger.info(
+                            "Izlaižu auto-continue no %s, jo trūkst modeļa saderības metadata.",
+                            resolved,
+                        )
+                    continue
             logger.info("Turpinu treniņu no lokālā artefakta: %s", resolved)
             return str(resolved)
 
@@ -1129,6 +1236,7 @@ def _build_training_artifact_config(config: TrainingConfig) -> dict[str, Any]:
     payload = config.to_dict().copy()
     payload.pop("model_name", None)
     payload["model_preset"] = config.model_preset or "custom"
+    payload[MODEL_SOURCE_FINGERPRINT_KEY] = _build_model_source_fingerprint(config.model_name)
     payload["maris_origin"] = MARIS_ORIGIN_NAME
     payload["maris_framework"] = MARIS_FRAMEWORK_NAME
     payload["maris_model_id"] = config.hub_model_id
@@ -1141,7 +1249,9 @@ def _build_artifact_identity(config: TrainingConfig) -> dict[str, Any]:
         "maris_origin": MARIS_ORIGIN_NAME,
         "maris_framework": MARIS_FRAMEWORK_NAME,
         "dataset_repo": config.dataset_repo,
-        "eval_dataset_repo": config.eval_dataset_repo or config.dataset_repo,
+        "dataset_repos": _resolve_training_dataset_repos(config),
+        "eval_dataset_repo": _resolve_primary_eval_dataset_repo(config),
+        "eval_dataset_repos": _resolve_eval_dataset_repos(config),
         "branch_name": config.branch_name,
         "branch_focus": config.branch_focus,
     }
@@ -1227,7 +1337,9 @@ def _build_model_card(
             "## Training Data",
             "",
             f"- Dataset repo: `{config.dataset_repo}`",
-            f"- Eval dataset repo: `{config.eval_dataset_repo or config.dataset_repo}`",
+            f"- Dataset repos: `{', '.join(_resolve_training_dataset_repos(config))}`",
+            f"- Eval dataset repo: `{_resolve_primary_eval_dataset_repo(config)}`",
+            f"- Eval dataset repos: `{', '.join(_resolve_eval_dataset_repos(config) or [_resolve_primary_eval_dataset_repo(config)])}`",
             f"- Train examples: `{train_examples}`",
             f"- Eval examples: `{eval_examples}`",
             f"- Branch focus: `{config.branch_focus}`",
@@ -1283,7 +1395,9 @@ def _write_training_provenance(
         {
             "trained_at": trained_at,
             "dataset_repo": config.dataset_repo,
-            "eval_dataset_repo": config.eval_dataset_repo or config.dataset_repo,
+            "dataset_repos": _resolve_training_dataset_repos(config),
+            "eval_dataset_repo": _resolve_primary_eval_dataset_repo(config),
+            "eval_dataset_repos": _resolve_eval_dataset_repos(config),
             "branch_name": config.branch_name,
             "branch_focus": config.branch_focus,
             "adapter_type": config.adapter_type,
@@ -1666,7 +1780,9 @@ def _apply_branch_runtime_defaults(config: TrainingConfig) -> TrainingConfig:
         return config
     if not benchmark_dataset_path and config.benchmark_gate_enabled:
         benchmark_dataset_path = _resolve_branch_benchmark_dataset_path(config, config.branch_name)
-    if config.benchmark_gate_enabled and (not benchmark_name or benchmark_name == DEFAULT_BENCHMARK_NAME):
+    if config.benchmark_gate_enabled and (
+        not benchmark_name or benchmark_name == DEFAULT_BENCHMARK_NAME
+    ):
         benchmark_name = _resolve_branch_benchmark_name(config, config.branch_name)
     if not preference_dataset_path:
         preference_dataset_path = _resolve_branch_preference_dataset_path(
@@ -2568,9 +2684,19 @@ def train_with_config(config: TrainingConfig) -> dict[str, float]:
     """Apmāca modeli pēc pilnas konfigurācijas."""
     config = _apply_branch_runtime_defaults(_normalize_training_runtime_config(config))
     _ensure_runtime_home_dir()
+    training_dataset_repos = _resolve_training_dataset_repos(config)
+    eval_dataset_repos = _resolve_eval_dataset_repos(config)
     try:
-        logger.info("Ielādē training datasetu: %s", config.dataset_repo)
-        dataset = load_hf_dataset(config.dataset_repo)
+        _emit_training_progress_event(
+            "prepare_dataset",
+            stage="preparing",
+            label="Ielādē training datasetu",
+            total_epochs=config.num_epochs,
+            dataset_repo=config.dataset_repo,
+            dataset_repos=training_dataset_repos,
+        )
+        logger.info("Ielādē training datasetus: %s", ", ".join(training_dataset_repos))
+        dataset = _load_combined_hf_dataset(training_dataset_repos)
     except HFDatasetError as exc:
         logger.error("Apmācība apturēta: %s", exc)
         raise SystemExit(str(exc)) from None
@@ -2584,22 +2710,39 @@ def train_with_config(config: TrainingConfig) -> dict[str, float]:
             Trainer,
             TrainingArguments,
         )
+
         try:
             from transformers import TrainerCallback  # type: ignore
         except ImportError:  # pragma: no cover - fallback for lightweight test doubles
+
             class TrainerCallback:  # type: ignore[no-redef]
                 pass
 
         training_model_source = _resolve_training_model_source(config)
+        _emit_training_progress_event(
+            "prepare_model",
+            stage="preparing",
+            label="Ielādē tokenizeri un modeli",
+            total_epochs=config.num_epochs,
+            model_source=training_model_source,
+        )
         logger.info("Ielādē modeli: %s", training_model_source)
         tokenizer = _load_tokenizer(training_model_source, config)
         _configure_tokenizer(tokenizer, config)
         model = _prepare_training_model(training_model_source, tokenizer, config)
 
         train_split, eval_split = _prepare_train_eval_splits(dataset, config)
-        if config.eval_dataset_repo:
-            logger.info("Ielādē atsevišķu eval datasetu: %s", config.eval_dataset_repo)
-            eval_source_dataset = load_hf_dataset(config.eval_dataset_repo)
+        if eval_dataset_repos:
+            _emit_training_progress_event(
+                "prepare_eval_dataset",
+                stage="preparing",
+                label="Ielādē eval datasetu",
+                total_epochs=config.num_epochs,
+                dataset_repo=config.eval_dataset_repo or eval_dataset_repos[0],
+                dataset_repos=eval_dataset_repos,
+            )
+            logger.info("Ielādē atsevišķus eval datasetus: %s", ", ".join(eval_dataset_repos))
+            eval_source_dataset = _load_combined_hf_dataset(eval_dataset_repos)
             eval_split = _select_eval_split(
                 eval_source_dataset,
                 config,
@@ -2648,6 +2791,12 @@ def train_with_config(config: TrainingConfig) -> dict[str, float]:
                     expand_weights=False,
                     benchmark_feedback=benchmark_feedback,
                 )
+        _emit_training_progress_event(
+            "prepare_tokenization",
+            stage="preparing",
+            label="Tokenizē treniņa un eval datus",
+            total_epochs=config.num_epochs,
+        )
         train_dataset = _tokenize_dataset(train_split, tokenizer, config.max_seq_length)
         eval_dataset = (
             _tokenize_dataset(eval_split, tokenizer, config.max_seq_length)
@@ -2655,6 +2804,12 @@ def train_with_config(config: TrainingConfig) -> dict[str, float]:
             else None
         )
 
+        _emit_training_progress_event(
+            "prepare_runtime",
+            stage="preparing",
+            label="Sagatavo treneri un runtime",
+            total_epochs=config.num_epochs,
+        )
         training_args = _build_training_arguments(
             TrainingArguments,
             output_dir=config.output_dir,
@@ -2908,8 +3063,10 @@ def evaluate_with_config(
     """Novērtē modeli ar to pašu datu pipeline, ko izmanto apmācībai."""
     config = _apply_branch_runtime_defaults(config)
     _ensure_runtime_home_dir()
+    eval_dataset_repos = _resolve_eval_dataset_repos(config)
+    dataset_repos = eval_dataset_repos or _resolve_training_dataset_repos(config)
     try:
-        dataset = load_hf_dataset(config.eval_dataset_repo or config.dataset_repo)
+        dataset = _load_combined_hf_dataset(dataset_repos)
     except HFDatasetError as exc:
         logger.error("Novērtēšana apturēta: %s", exc)
         raise SystemExit(str(exc)) from None
@@ -2925,7 +3082,7 @@ def evaluate_with_config(
     _configure_tokenizer(tokenizer, config)
     model = _load_model(resolved_model, config)
 
-    if config.eval_dataset_repo:
+    if eval_dataset_repos:
         reference_split = _select_eval_split(dataset, config, allow_train_fallback=True)
     else:
         train_split, eval_split = _prepare_train_eval_splits(dataset, config)
@@ -2997,7 +3154,9 @@ def train(
     config_path: str | None = None,
     model_name: str | None = None,
     dataset_repo: str | None = None,
+    dataset_repos: str | list[str] | None = None,
     eval_dataset_repo: str | None = None,
+    eval_dataset_repos: str | list[str] | None = None,
     benchmark_dataset_path: str | None = None,
     benchmark_feedback_path: str | None = None,
     preference_dataset_path: str | None = None,
@@ -3040,7 +3199,9 @@ def train(
         overrides={
             "model_name": model_name,
             "dataset_repo": dataset_repo,
+            "dataset_repos": dataset_repos,
             "eval_dataset_repo": eval_dataset_repo,
+            "eval_dataset_repos": eval_dataset_repos,
             "benchmark_dataset_path": benchmark_dataset_path,
             "benchmark_feedback_path": benchmark_feedback_path,
             "preference_dataset_path": preference_dataset_path,

core-python/scripts/export_to_hf.py

@@ -13,6 +13,14 @@ from maris_core.utils.env import validate_maris_model
 logger = logging.getLogger(__name__)
 
 
+def _getenv_any(*names: str, default: str) -> str:
+    for name in names:
+        value = os.getenv(name, "").strip()
+        if value:
+            return value
+    return default
+
+
 def _upload_folder(api: object, folder_path: str, repo_id: str, commit_message: str) -> None:
     logger.info("Eksportē modeli: %s -> %s", folder_path, repo_id)
     api.create_repo(repo_id=repo_id, repo_type="model", exist_ok=True)
@@ -36,7 +44,18 @@ def _branch_suite_export_targets(
 
     suite = json.loads(manifest_path.read_text(encoding="utf-8"))
     branch_exports = {
-        "master": os.getenv("TEXT_MODEL", "MarisUK/maris-ai-text"),
+        "master": _getenv_any(
+            "MARIS_TEXT_MODEL_REPO",
+            "HF_TEXT_MODEL_REPO",
+            "TEXT_MODEL",
+            default="MarisUK/maris-ai-lv",
+        ),
+        "coder": _getenv_any(
+            "MARIS_CODEX_MODEL_REPO",
+            "HF_CODEX_MODEL_REPO",
+            "CODEX_MODEL",
+            default="MarisUK/maris-ai-codex",
+        ),
         "image": os.getenv("IMAGE_MODEL", "MarisUK/maris-ai-image"),
         "music": os.getenv("MUSIC_MODEL", "MarisUK/maris-ai-music"),
         "tts": os.getenv("TTS_MODEL", "MarisUK/maris-tts-runtime"),

core-python/tests/test_autonomous.py

@@ -1,12 +1,27 @@
 """Tests for stronger autonomous planning execution."""
 
+import asyncio
 from unittest.mock import patch
 
 import pytest
 
 from maris_core.autonomous.agent import StartRequest, StatusRequest, get_status, start_session
+from maris_core.autonomous.planner import Planner
 from maris_core.memory_context import ConversationMemoryStore
 
+BACKGROUND_TASK_SETTLE_SECONDS = 0.3
+
+
+def test_planner_decompose_splits_goal_without_regex_backtracking() -> None:
+    planner = Planner()
+
+    steps = planner.decompose("Ievāc datus un tad salīdzini rezultātus -> pārbaudi kopsavilkumu")
+
+    assert [step["action"] for step in steps[1:3]] == [
+        "Ievāc datus",
+        "salīdzini rezultātus",
+    ]
+
 
 @pytest.mark.asyncio
 async def test_autonomous_session_executes_dependent_tasks_over_status_polls() -> None:
@@ -35,6 +50,7 @@ async def test_autonomous_task_retries_before_failing() -> None:
         ) as execute_task_mock,
     ):
         started = await start_session(StartRequest(session_id="session-2", goal="Debugot servisu"))
+        await asyncio.sleep(BACKGROUND_TASK_SETTLE_SECONDS)
         retried = await get_status(StatusRequest(session_id="session-2"))
 
     assert execute_task_mock.await_count == 2
@@ -47,6 +63,36 @@ async def test_autonomous_task_retries_before_failing() -> None:
     assert any(event.event_type == "task.failed_attempt" for event in retried.events)
 
 
+@pytest.mark.asyncio
+async def test_autonomous_session_keeps_running_without_status_polls() -> None:
+    async def fake_execute_task(
+        task: dict[str, object],
+        goal: str,
+        tasks: list[dict[str, object]],
+        *,
+        persona_id: str | None = None,
+    ) -> dict[str, object]:
+        del goal, tasks, persona_id
+        return {"summary": f"Pabeigts: {task['description']}", "artifacts": {}, "metrics": {}}
+
+    with (
+        patch("maris_core.autonomous.agent.get_pipeline", return_value=None),
+        patch("maris_core.autonomous.agent._execute_task", side_effect=fake_execute_task),
+    ):
+        started = await start_session(
+            StartRequest(session_id="session-auto", goal="Uztaisīt plānu")
+        )
+        assert started.tasks[0].status == "completed"
+
+        await asyncio.sleep(BACKGROUND_TASK_SETTLE_SECONDS)
+        current = await get_status(StatusRequest(session_id="session-auto"))
+
+    assert current.status == "completed"
+    assert current.progress_percent == 100
+    assert all(task.status == "completed" for task in current.tasks)
+    assert any(event.event_type == "session.completed" for event in current.events)
+
+
 @pytest.mark.asyncio
 async def test_autonomous_session_preserves_selected_persona() -> None:
     captured_messages: list[dict[str, str]] = []

core-python/tests/test_autonomous_runtime.py

@@ -27,7 +27,9 @@ async def test_autonomous_session_recovers_from_persistent_store(tmp_path: Path)
         patch("maris_core.autonomous.agent.session_store", store),
         patch("maris_core.autonomous.agent.get_pipeline", return_value=None),
     ):
-        started = await start_session(StartRequest(session_id="persisted-session", goal="Uztaisīt plānu"))
+        started = await start_session(
+            StartRequest(session_id="persisted-session", goal="Uztaisīt plānu")
+        )
         _sessions.clear()
         recovered = await get_status(StatusRequest(session_id="persisted-session"))
 
@@ -43,7 +45,12 @@ async def test_autonomous_session_recovers_from_persistent_store(tmp_path: Path)
 @pytest.mark.asyncio
 async def test_executor_runs_reasoning_with_runtime_generate() -> None:
     executor = AutonomousTaskExecutor()
-    task = {"id": "task-1", "description": "Nosaki prioritātes", "tool": "reasoning", "depends_on": []}
+    task = {
+        "id": "task-1",
+        "description": "Nosaki prioritātes",
+        "tool": "reasoning",
+        "depends_on": [],
+    }
 
     fake_response = SimpleNamespace(
         response="Konkrēts darba rezultāts",

core-python/tests/test_code.py

@@ -81,7 +81,9 @@ async def test_generate_code_requires_text_model() -> None:
 
 
 @pytest.mark.asyncio
-async def test_generate_code_uses_requested_hf_fallback_model_when_text_runtime_is_unavailable() -> None:
+async def test_generate_code_uses_requested_hf_fallback_model_when_text_runtime_is_unavailable() -> (
+    None
+):
     class FakeClient:
         def chat_completion(
             self,
@@ -109,7 +111,9 @@ async def test_generate_code_uses_requested_hf_fallback_model_when_text_runtime_
     with (
         patch("maris_core.code.generate_code.get_pipeline", return_value=None),
         patch("maris_core.text.generate.create_hf_inference_client", return_value=FakeClient()),
-        patch.dict(sys.modules, {"huggingface_hub": fake_hf_module, "huggingface_hub.utils": fake_hf_utils}),
+        patch.dict(
+            sys.modules, {"huggingface_hub": fake_hf_module, "huggingface_hub.utils": fake_hf_utils}
+        ),
         patch(
             "maris_core.utils.hf_integration.HFIntegration.save_generation",
             new_callable=AsyncMock,
@@ -199,7 +203,9 @@ async def test_generate_code_uses_stronger_engineering_system_prompt() -> None:
 
 
 @pytest.mark.asyncio
-async def test_generate_code_materializes_workspace_artifacts_from_structured_payload(tmp_path) -> None:
+async def test_generate_code_materializes_workspace_artifacts_from_structured_payload(
+    tmp_path,
+) -> None:
     def fake_pipeline(
         messages: list[dict[str, Any]], *, max_new_tokens: int, temperature: float
     ) -> list[dict[str, list[dict[str, str]]]]:
@@ -244,8 +250,10 @@ async def test_generate_code_materializes_workspace_artifacts_from_structured_pa
     assert [file.path for file in response.files] == ["index.html", "assets/app.js"]
     assert response.files[0].absolute_path is not None
     assert bundle_path.exists()
-    assert Path(response.files[0].absolute_path or "").read_text(encoding="utf-8").startswith(
-        "<!doctype html>"
+    assert (
+        Path(response.files[0].absolute_path or "")
+        .read_text(encoding="utf-8")
+        .startswith("<!doctype html>")
     )
 
 
@@ -302,7 +310,9 @@ async def test_generate_code_uses_repo_aware_entrypoint_for_existing_project(tmp
         "[project]\nname = 'demo'\nversion = '0.1.0'\n",
         encoding="utf-8",
     )
-    (project_root / "src/main.py").write_text("def main() -> None:\n    print('old')\n", encoding="utf-8")
+    (project_root / "src/main.py").write_text(
+        "def main() -> None:\n    print('old')\n", encoding="utf-8"
+    )
 
     captured_messages: list[dict[str, Any]] = []
 

core-python/tests/test_huggingface_human_training_space_studio.py

@@ -89,7 +89,9 @@ def test_build_populates_run_history_and_artifact_browser(monkeypatch, tmp_path:
     )
     draft_id = draft_response.json()["draft"]["draft_id"]
 
-    build_response = client.post(f"/api/human-training/build?draft_id={draft_id}", json=_sample_payload())
+    build_response = client.post(
+        f"/api/human-training/build?draft_id={draft_id}", json=_sample_payload()
+    )
 
     assert build_response.status_code == 200
     body = build_response.json()

core-python/tests/test_huggingface_sync.py

@@ -148,6 +148,126 @@ def test_space_uploads_pass_space_sdk(
     assert payload["argv"][4:] == ["token", "", sdk_value]
 
 
+def test_upload_model_publishes_branch_suite_text_and_codex_repos(tmp_path: Path) -> None:
+    repo_root = tmp_path / "repo"
+    model_root = repo_root / "core-python" / "output" / "model"
+    (repo_root / "huggingface").mkdir(parents=True)
+    (repo_root / "core-python" / "output").mkdir(parents=True)
+    (model_root / "master").mkdir(parents=True)
+    (model_root / "coder").mkdir(parents=True)
+    (repo_root / "huggingface" / "sync.sh").write_text(
+        SYNC_SCRIPT_PATH.read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "model-card.md").write_text(
+        "# Model card\n",
+        encoding="utf-8",
+    )
+    (model_root / "config.json").write_text("{}", encoding="utf-8")
+    (model_root / "master" / "config.json").write_text("{}", encoding="utf-8")
+    (model_root / "coder" / "config.json").write_text("{}", encoding="utf-8")
+    (model_root / "branch-suite.json").write_text(
+        json.dumps(
+            {
+                "branches": {
+                    "master": {"output_dir": "core-python/output/model/master"},
+                    "coder": {"output_dir": "core-python/output/model/coder"},
+                }
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    fake_bin = tmp_path / "bin"
+    fake_bin.mkdir()
+    log_path = tmp_path / "python-log.jsonl"
+    python_wrapper = fake_bin / "python3"
+    python_wrapper.write_text(
+        "\n".join(
+            [
+                f"#!{sys.executable}",
+                "import json, os, sys",
+                "log_path = os.environ['HF_TEST_LOG']",
+                "entry = {'argv': sys.argv[1:], 'stdin': sys.stdin.read()}",
+                "with open(log_path, 'a', encoding='utf-8') as handle:",
+                "    handle.write(json.dumps(entry) + '\\n')",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-c':",
+                "    raise SystemExit(0)",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-':",
+                "    if len(sys.argv) >= 6 and sys.argv[2].endswith('branch-suite.json'):",
+                "        manifest_path = sys.argv[2]",
+                "        repo_root = sys.argv[3]",
+                "        text_repo = sys.argv[4]",
+                "        codex_repo = sys.argv[5]",
+                "        payload = json.load(open(manifest_path, encoding='utf-8'))",
+                "        branches = payload.get('branches', {})",
+                "        for branch_name, repo_id in (('master', text_repo), ('coder', codex_repo)):",
+                "            output_dir = branches.get(branch_name, {}).get('output_dir', '')",
+                "            if output_dir and repo_id:",
+                "                print(f'{branch_name}\\t{repo_root}/{output_dir}\\t{repo_id}')",
+                "    raise SystemExit(0)",
+                "raise SystemExit(f'unexpected python3 invocation: {sys.argv!r}')",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    python_wrapper.chmod(python_wrapper.stat().st_mode | stat.S_IEXEC)
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "PATH": f"{fake_bin}:{env['PATH']}",
+            "HF_TEST_LOG": str(log_path),
+            "MARIS_REPO_TOKEN": "token",
+            "HF_MODEL_REPO": "MarisUK/maris-ai-master",
+            "HF_TEXT_MODEL_REPO": "MarisUK/maris-ai-lv",
+            "HF_CODEX_MODEL_REPO": "MarisUK/maris-ai-codex",
+            "HF_LOCAL_MODEL_DIR": str(model_root),
+        }
+    )
+
+    subprocess.run(
+        ["bash", str(repo_root / "huggingface" / "sync.sh"), "upload-model"],
+        cwd=repo_root,
+        env=env,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    payloads = [
+        json.loads(line)
+        for line in log_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    workspace_uploads = [
+        payload
+        for payload in payloads
+        if payload["argv"] and payload["argv"][0] == "-" and len(payload["argv"]) >= 5 and payload["argv"][2] == "model"
+    ]
+    card_uploads = [
+        payload
+        for payload in payloads
+        if payload["argv"]
+        and payload["argv"][0] == "-"
+        and len(payload["argv"]) == 5
+        and payload["argv"][2] == str(repo_root / "huggingface" / "model-card.md")
+    ]
+
+    assert [(payload["argv"][1], payload["argv"][4]) for payload in workspace_uploads] == [
+        ("MarisUK/maris-ai-master", "Maris AI model sync"),
+        ("MarisUK/maris-ai-lv", "Maris AI model sync (master)"),
+        ("MarisUK/maris-ai-codex", "Maris AI model sync (coder)"),
+    ]
+    assert all(payload["argv"][3].startswith("/tmp/") for payload in workspace_uploads)
+    assert [(payload["argv"][1], payload["argv"][3], payload["argv"][4]) for payload in card_uploads] == [
+        ("MarisUK/maris-ai-master", "Maris AI model sync", "token"),
+        ("MarisUK/maris-ai-lv", "Maris AI model sync (master)", "token"),
+        ("MarisUK/maris-ai-codex", "Maris AI model sync (coder)", "token"),
+    ]
+
+
 def test_upload_dataset_also_publishes_optional_eval_repo(tmp_path: Path) -> None:
     repo_root = tmp_path / "repo"
     (repo_root / "huggingface").mkdir(parents=True)
@@ -275,6 +395,165 @@ def test_upload_dataset_also_publishes_optional_eval_repo(tmp_path: Path) -> Non
     ]
 
 
+def test_upload_dataset_can_publish_global_memory_eval_and_benchmark_repos(
+    tmp_path: Path,
+) -> None:
+    repo_root = tmp_path / "repo"
+    (repo_root / "huggingface").mkdir(parents=True)
+    (repo_root / "core-python" / "scripts").mkdir(parents=True)
+    for dataset_dir in ("data", "eval-data", "benchmark-data"):
+        (repo_root / dataset_dir / "conversation").mkdir(parents=True)
+    (repo_root / "huggingface" / "sync.sh").write_text(
+        SYNC_SCRIPT_PATH.read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "dataset-card.md").write_text(
+        "# Dataset card\n",
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "global-memory-dataset-card.md").write_text(
+        "# Global memory dataset card\n",
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "eval-dataset-card.md").write_text(
+        "# Eval dataset card\n",
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "benchmark-dataset-card.md").write_text(
+        "# Benchmark dataset card\n",
+        encoding="utf-8",
+    )
+    (repo_root / "core-python" / "scripts" / "validate_datasets.py").write_text(
+        "print('ok')\n",
+        encoding="utf-8",
+    )
+    (repo_root / "data" / "conversation" / "sample.jsonl").write_text(
+        '{"timestamp":"2026-04-06T00:02:00Z","type":"conversation","session_id":"main-1","user":"u","assistant":"a","language":"lv","source":"test"}\n',
+        encoding="utf-8",
+    )
+    eval_record = (
+        '{"timestamp":"2026-04-06T00:03:00Z","type":"conversation","session_id":"eval-1",'
+        '"user":"u","assistant":"a","language":"lv","source":"test","task_id":"eval-1",'
+        '"benchmark_version":"maris-evals-v1","suite":"sanity","difficulty":"easy",'
+        '"evaluation_mode":"reference-review","risk_level":"low","expected_behavior":["ok"],'
+        '"scoring_hints":["ok"],"reference_answer":"a","acceptance_criteria":["ok"]}\n'
+    )
+    (repo_root / "eval-data" / "conversation" / "sample.jsonl").write_text(
+        eval_record,
+        encoding="utf-8",
+    )
+    benchmark_record = (
+        '{"timestamp":"2026-04-06T00:04:00Z","type":"conversation","session_id":"bench-1",'
+        '"user":"u","assistant":"a","language":"en","source":"test","task_id":"bench-1",'
+        '"benchmark_version":"maris-benchmark-v1","suite":"release","difficulty":"medium",'
+        '"evaluation_mode":"reference-review","risk_level":"high","expected_behavior":["ok"],'
+        '"scoring_hints":["ok"],"reference_answer":"a","acceptance_criteria":["ok"]}\n'
+    )
+    (repo_root / "benchmark-data" / "conversation" / "sample.jsonl").write_text(
+        benchmark_record,
+        encoding="utf-8",
+    )
+
+    fake_bin = tmp_path / "bin"
+    fake_bin.mkdir()
+    log_path = tmp_path / "python-log.jsonl"
+    python_wrapper = fake_bin / "python3"
+    python_wrapper.write_text(
+        "\n".join(
+            [
+                f"#!{sys.executable}",
+                "import json, os, sys",
+                "log_path = os.environ['HF_TEST_LOG']",
+                "entry = {'argv': sys.argv[1:], 'stdin': sys.stdin.read()}",
+                "with open(log_path, 'a', encoding='utf-8') as handle:",
+                "    handle.write(json.dumps(entry) + '\\n')",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-c':",
+                "    raise SystemExit(0)",
+                "if len(sys.argv) > 1 and sys.argv[1].endswith('validate_datasets.py'):",
+                "    raise SystemExit(0)",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-':",
+                "    raise SystemExit(0)",
+                "raise SystemExit(f'unexpected python3 invocation: {sys.argv!r}')",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    python_wrapper.chmod(python_wrapper.stat().st_mode | stat.S_IEXEC)
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "PATH": f"{fake_bin}:{env['PATH']}",
+            "HF_TEST_LOG": str(log_path),
+            "MARIS_REPO_TOKEN": "token",
+            "HF_DATASET_REPO": "MarisUK/maris-ai-lv-memory",
+            "HF_GLOBAL_MEMORY_REPO": "MarisUK/maris-ai-memory",
+            "HF_EVAL_DATASET_REPO": "MarisUK/maris-ai-evals",
+            "HF_BENCHMARK_DATASET_REPO": "MarisUK/maris-ai-benchmark",
+            "HF_LOCAL_DATASET_DIR": str(repo_root / "data"),
+            "HF_LOCAL_GLOBAL_DATASET_DIR": str(repo_root / "data"),
+            "HF_LOCAL_EVAL_DATASET_DIR": str(repo_root / "eval-data"),
+            "HF_LOCAL_BENCHMARK_DATASET_DIR": str(repo_root / "benchmark-data"),
+        }
+    )
+
+    subprocess.run(
+        ["bash", str(repo_root / "huggingface" / "sync.sh"), "upload-dataset"],
+        cwd=repo_root,
+        env=env,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    payloads = [
+        json.loads(line)
+        for line in log_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    upload_payloads = [
+        payload for payload in payloads if payload["argv"] and payload["argv"][0] == "-"
+    ]
+    validate_payloads = [
+        payload
+        for payload in payloads
+        if payload["argv"] and payload["argv"][0].endswith("validate_datasets.py")
+    ]
+
+    assert [payload["argv"][1:] for payload in validate_payloads] == [
+        ["--profile", "bootstrap", str(repo_root / "data")],
+        ["--profile", "bootstrap", str(repo_root / "data")],
+        ["--profile", "eval", str(repo_root / "eval-data")],
+        ["--profile", "eval", str(repo_root / "benchmark-data")],
+    ]
+    assert len(upload_payloads) == 8
+    assert upload_payloads[2]["argv"][1:5] == [
+        "MarisUK/maris-ai-memory",
+        "dataset",
+        upload_payloads[2]["argv"][3],
+        "Maris AI global memory dataset sync",
+    ]
+    assert upload_payloads[3]["argv"][1:5] == [
+        "MarisUK/maris-ai-memory",
+        str(repo_root / "huggingface" / "global-memory-dataset-card.md"),
+        "Maris AI global memory dataset sync",
+        "token",
+    ]
+    assert upload_payloads[6]["argv"][1:5] == [
+        "MarisUK/maris-ai-benchmark",
+        "dataset",
+        upload_payloads[6]["argv"][3],
+        "Maris AI benchmark dataset sync",
+    ]
+    assert upload_payloads[7]["argv"][1:5] == [
+        "MarisUK/maris-ai-benchmark",
+        str(repo_root / "huggingface" / "benchmark-dataset-card.md"),
+        "Maris AI benchmark dataset sync",
+        "token",
+    ]
+
+
 def test_upload_dataset_uses_bundled_eval_data_by_default(tmp_path: Path) -> None:
     repo_root = tmp_path / "repo"
     (repo_root / "huggingface").mkdir(parents=True)
@@ -371,6 +650,111 @@ def test_upload_dataset_uses_bundled_eval_data_by_default(tmp_path: Path) -> Non
     ]
 
 
+@pytest.mark.parametrize("command", ["upload-benchmark-dataset", "upload-benchmark-data"])
+def test_upload_benchmark_dataset_only_publishes_benchmark_repo(
+    tmp_path: Path, command: str
+) -> None:
+    repo_root = tmp_path / "repo"
+    (repo_root / "huggingface").mkdir(parents=True)
+    (repo_root / "core-python" / "scripts").mkdir(parents=True)
+    (repo_root / "benchmark-data" / "conversation").mkdir(parents=True)
+    (repo_root / "huggingface" / "sync.sh").write_text(
+        SYNC_SCRIPT_PATH.read_text(encoding="utf-8"),
+        encoding="utf-8",
+    )
+    (repo_root / "huggingface" / "benchmark-dataset-card.md").write_text(
+        "# Benchmark dataset card\n",
+        encoding="utf-8",
+    )
+    (repo_root / "core-python" / "scripts" / "validate_datasets.py").write_text(
+        "print('ok')\n",
+        encoding="utf-8",
+    )
+    (repo_root / "benchmark-data" / "conversation" / "sample.jsonl").write_text(
+        '{"timestamp":"2026-04-06T00:04:00Z","type":"conversation","session_id":"bench-1","user":"u","assistant":"a","language":"en","source":"test","task_id":"bench-1","benchmark_version":"maris-benchmark-v1","suite":"release","difficulty":"medium","evaluation_mode":"reference-review","risk_level":"high","expected_behavior":["ok"],"scoring_hints":["ok"],"reference_answer":"a","acceptance_criteria":["ok"]}\n',
+        encoding="utf-8",
+    )
+
+    fake_bin = tmp_path / "bin"
+    fake_bin.mkdir()
+    log_path = tmp_path / "python-log.jsonl"
+    python_wrapper = fake_bin / "python3"
+    python_wrapper.write_text(
+        "\n".join(
+            [
+                f"#!{sys.executable}",
+                "import json, os, sys",
+                "log_path = os.environ['HF_TEST_LOG']",
+                "entry = {'argv': sys.argv[1:], 'stdin': sys.stdin.read()}",
+                "with open(log_path, 'a', encoding='utf-8') as handle:",
+                "    handle.write(json.dumps(entry) + '\\n')",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-c':",
+                "    raise SystemExit(0)",
+                "if len(sys.argv) > 1 and sys.argv[1].endswith('validate_datasets.py'):",
+                "    raise SystemExit(0)",
+                "if len(sys.argv) > 1 and sys.argv[1] == '-':",
+                "    raise SystemExit(0)",
+                "raise SystemExit(f'unexpected python3 invocation: {sys.argv!r}')",
+                "",
+            ]
+        ),
+        encoding="utf-8",
+    )
+    python_wrapper.chmod(python_wrapper.stat().st_mode | stat.S_IEXEC)
+
+    env = os.environ.copy()
+    env.update(
+        {
+            "PATH": f"{fake_bin}:{env['PATH']}",
+            "HF_TEST_LOG": str(log_path),
+            "MARIS_REPO_TOKEN": "token",
+            "HF_DATASET_REPO": "MarisUK/maris-ai-lv-memory",
+            "HF_BENCHMARK_DATASET_REPO": "MarisUK/maris-ai-benchmark",
+            "HF_LOCAL_BENCHMARK_DATASET_DIR": str(repo_root / "benchmark-data"),
+        }
+    )
+
+    subprocess.run(
+        ["bash", str(repo_root / "huggingface" / "sync.sh"), command],
+        cwd=repo_root,
+        env=env,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    payloads = [
+        json.loads(line)
+        for line in log_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    upload_payloads = [
+        payload for payload in payloads if payload["argv"] and payload["argv"][0] == "-"
+    ]
+    validate_payloads = [
+        payload
+        for payload in payloads
+        if payload["argv"] and payload["argv"][0].endswith("validate_datasets.py")
+    ]
+
+    assert [payload["argv"][1:] for payload in validate_payloads] == [
+        ["--profile", "eval", str(repo_root / "benchmark-data")]
+    ]
+    assert len(upload_payloads) == 2
+    assert upload_payloads[0]["argv"][1:5] == [
+        "MarisUK/maris-ai-benchmark",
+        "dataset",
+        upload_payloads[0]["argv"][3],
+        "Maris AI benchmark dataset sync",
+    ]
+    assert upload_payloads[1]["argv"][1:5] == [
+        "MarisUK/maris-ai-benchmark",
+        str(repo_root / "huggingface" / "benchmark-dataset-card.md"),
+        "Maris AI benchmark dataset sync",
+        "token",
+    ]
+
+
 @pytest.mark.parametrize("command", ["upload-eval-dataset", "upload-evals-data"])
 def test_upload_eval_dataset_only_publishes_eval_repo(tmp_path: Path, command: str) -> None:
     repo_root = tmp_path / "repo"

core-python/tests/test_human_training.py

@@ -39,8 +39,14 @@ def test_stage_human_training_artifacts_builds_staging_manifest(tmp_path: Path)
         profile_preferences=["Atbildi latviski."],
         response_instructions=["Ja iespējams, dod strukturētu kopsavilkumu."],
         conversation_examples=[
-            {"user": "Kas ir mana valodas preference?", "assistant": "Tu dod priekšroku latviešu valodai."},
-            {"user": "Kas ir mana valodas preference?", "assistant": "Tu dod priekšroku latviešu valodai."},
+            {
+                "user": "Kas ir mana valodas preference?",
+                "assistant": "Tu dod priekšroku latviešu valodai.",
+            },
+            {
+                "user": "Kas ir mana valodas preference?",
+                "assistant": "Tu dod priekšroku latviešu valodai.",
+            },
         ],
         preference_pairs=[
             {

core-python/tests/test_space_agent.py

@@ -236,7 +236,9 @@ def test_execute_space_agent_tool_returns_model_dataset_playbook() -> None:
     assert "latest_agent_principles" in result
     assert "recommended_loop" in result
     assert "validate_dataset" in result["repo_commands"]
-    assert any("HF_TOKEN" in item or "MARIS_REPO_TOKEN" in item for item in result["required_setup"])
+    assert any(
+        "HF_TOKEN" in item or "MARIS_REPO_TOKEN" in item for item in result["required_setup"]
+    )
 
 
 def test_execute_space_agent_tool_returns_browser_capabilities() -> None:
@@ -253,7 +255,9 @@ def test_execute_space_agent_tool_returns_workspace_command_catalog() -> None:
 
     assert result["presets"]
     assert any(group["category"] == "python" for group in result["presets"])
-    assert any(item["id"] == "frontend-build" for group in result["presets"] for item in group["items"])
+    assert any(
+        item["id"] == "frontend-build" for group in result["presets"] for item in group["items"]
+    )
 
 
 def test_execute_space_agent_tool_returns_persona_catalog() -> None:
@@ -396,8 +400,10 @@ def test_execute_space_agent_tool_stages_workspace_write_when_approval_required(
             "workspace_root": str(workspace),
             "require_workspace_approval": True,
             "task_mode": "code",
-            "stage_workspace_write": lambda payload: staged_payloads.append(payload)
-            or {"proposal_id": "workspace-1", "status": "pending", "diff": "draft diff"},
+            "stage_workspace_write": lambda payload: (
+                staged_payloads.append(payload)
+                or {"proposal_id": "workspace-1", "status": "pending", "diff": "draft diff"}
+            ),
         },
     )
 
@@ -427,8 +433,10 @@ def test_execute_space_agent_tool_stages_huggingface_write_when_approval_require
         context={
             "require_publish_approval": True,
             "task_mode": "design",
-            "stage_hf_write": lambda payload: staged_payloads.append(payload)
-            or {"proposal_id": "proposal-1", "status": "pending"},
+            "stage_hf_write": lambda payload: (
+                staged_payloads.append(payload)
+                or {"proposal_id": "proposal-1", "status": "pending"}
+            ),
         },
     )
 
@@ -513,8 +521,9 @@ def test_generate_space_agent_reply_supports_multi_step_model_fix(
         tool_context={
             "require_publish_approval": True,
             "task_mode": "improve",
-            "stage_hf_write": lambda payload: staged.append(payload)
-            or {"proposal_id": "approval-1", "status": "pending"},
+            "stage_hf_write": lambda payload: (
+                staged.append(payload) or {"proposal_id": "approval-1", "status": "pending"}
+            ),
         },
     )
 

core-python/tests/test_space_ui.py

@@ -205,6 +205,20 @@ def test_parse_training_progress_detects_epoch_and_loss() -> None:
     assert progress["loss"] == 0.125
 
 
+def test_parse_training_progress_reports_structured_preparing_stage() -> None:
+    progress = parse_training_progress(
+        '{"maris_training_event": true, "event": "prepare_model", "stage": "preparing", "label": "Ielādē tokenizeri un modeli"}\n',
+        request={"num_epochs": 3},
+        running=True,
+        exit_code=None,
+    )
+
+    assert progress["stage"] == "preparing"
+    assert progress["label"] == "Ielādē tokenizeri un modeli"
+    assert progress["percent"] == 20
+    assert progress["events_detected"] == 1
+
+
 def test_parse_training_progress_reports_completion() -> None:
     progress = parse_training_progress(
         "Training complete\n",

core-python/tests/test_text.py

@@ -203,7 +203,9 @@ def test_build_pipeline_wraps_runtime_model_in_compatibility_restore() -> None:
 
     with (
         _reset_pipeline_runtime(),
-        patch("maris_core.text.generate.resolve_text_model", return_value="custom-user/maris-runtime"),
+        patch(
+            "maris_core.text.generate.resolve_text_model", return_value="custom-user/maris-runtime"
+        ),
         patch.dict(sys.modules, {"transformers": SimpleNamespace(pipeline=fake_pipeline)}),
         patch("maris_core.text.generate.maris_hf_compatible_path", fake_compat_path),
     ):
@@ -312,10 +314,14 @@ async def test_generate_uses_requested_hf_fallback_model_when_runtime_is_unavail
         def __init__(self) -> None:
             self.called_model: str | None = None
 
-        def chat_completion(self, *, model: str, messages: list[dict[str, str]], max_tokens: int, temperature: float) -> dict[str, Any]:
+        def chat_completion(
+            self, *, model: str, messages: list[dict[str, str]], max_tokens: int, temperature: float
+        ) -> dict[str, Any]:
             del messages, max_tokens, temperature
             self.called_model = model
-            return {"choices": [{"message": {"content": "Šī ir īsta fallback atbilde no HF modeļa."}}]}
+            return {
+                "choices": [{"message": {"content": "Šī ir īsta fallback atbilde no HF modeļa."}}]
+            }
 
     fake_client = FakeClient()
     fake_hf_module = SimpleNamespace(InferenceClient=FakeClient)
@@ -324,7 +330,9 @@ async def test_generate_uses_requested_hf_fallback_model_when_runtime_is_unavail
     with (
         patch("maris_core.text.generate.get_pipeline", return_value=None),
         patch("maris_core.text.generate.create_hf_inference_client", return_value=fake_client),
-        patch.dict(sys.modules, {"huggingface_hub": fake_hf_module, "huggingface_hub.utils": fake_hf_utils}),
+        patch.dict(
+            sys.modules, {"huggingface_hub": fake_hf_module, "huggingface_hub.utils": fake_hf_utils}
+        ),
         patch(
             "maris_core.utils.hf_integration.HFIntegration.save_conversation",
             new_callable=AsyncMock,

core-python/tests/test_text_benchmark.py

@@ -580,7 +580,9 @@ def test_summarize_chat_benchmark_tracks_memory_metrics_and_trends() -> None:
     assert history["trend_summary"]["average_latency_ms"]["latest"] == 80.0
 
 
-def test_summarize_chat_benchmark_tracks_tool_multimodal_latency_and_hallucination_metrics() -> None:
+def test_summarize_chat_benchmark_tracks_tool_multimodal_latency_and_hallucination_metrics() -> (
+    None
+):
     results = [
         ChatBenchmarkResult(
             name="tooling-case",

core-python/tests/test_training_hf_compat.py

@@ -47,9 +47,13 @@ def test_write_maris_compatibility_artifact_sanitizes_loader_fields(tmp_path: Pa
     write_maris_compatibility_artifact(output_dir, maris_model_id="MarisUK/maris-ai-master")
     apply_maris_compatibility_identity(output_dir)
 
-    manifest = json.loads((output_dir / MARIS_COMPATIBILITY_ARTIFACT_NAME).read_text(encoding="utf-8"))
+    manifest = json.loads(
+        (output_dir / MARIS_COMPATIBILITY_ARTIFACT_NAME).read_text(encoding="utf-8")
+    )
     config_payload = json.loads((output_dir / "config.json").read_text(encoding="utf-8"))
-    tokenizer_payload = json.loads((output_dir / "tokenizer_config.json").read_text(encoding="utf-8"))
+    tokenizer_payload = json.loads(
+        (output_dir / "tokenizer_config.json").read_text(encoding="utf-8")
+    )
     adapter_payload = json.loads((output_dir / "adapter_config.json").read_text(encoding="utf-8"))
 
     assert manifest["artifact_type"] == "maris-hf-compatibility"
@@ -97,7 +101,9 @@ def test_maris_hf_compatible_path_restores_remote_snapshot(monkeypatch, tmp_path
     with maris_hf_compatible_path("MarisUK/maris-ai-master") as compatible_path:
         restored_dir = Path(compatible_path)
         assert restored_dir != snapshot_dir
-        restored_config = json.loads(restored_dir.joinpath("config.json").read_text(encoding="utf-8"))
+        restored_config = json.loads(
+            restored_dir.joinpath("config.json").read_text(encoding="utf-8")
+        )
         assert restored_config["model_type"] == "qwen2"
         assert restored_config["architectures"] == ["Qwen2ForCausalLM"]
 
@@ -105,7 +111,9 @@ def test_maris_hf_compatible_path_restores_remote_snapshot(monkeypatch, tmp_path
     assert original_config["model_type"] == "maris"
 
 
-def test_maris_hf_compatible_path_restores_custom_runtime_snapshot(monkeypatch, tmp_path: Path) -> None:
+def test_maris_hf_compatible_path_restores_custom_runtime_snapshot(
+    monkeypatch, tmp_path: Path
+) -> None:
     snapshot_dir = tmp_path / "custom-runtime"
     snapshot_dir.mkdir()
     (snapshot_dir / "config.json").write_text(
@@ -127,7 +135,8 @@ def test_maris_hf_compatible_path_restores_custom_runtime_snapshot(monkeypatch,
         types.SimpleNamespace(
             snapshot_download=lambda **kwargs: (
                 str(snapshot_dir)
-                if kwargs["repo_id"] == "custom-user/maris-runtime" and kwargs["repo_type"] == "model"
+                if kwargs["repo_id"] == "custom-user/maris-runtime"
+                and kwargs["repo_type"] == "model"
                 else None
             )
         ),
@@ -136,7 +145,9 @@ def test_maris_hf_compatible_path_restores_custom_runtime_snapshot(monkeypatch,
 
     with maris_hf_compatible_path("custom-user/maris-runtime") as compatible_path:
         restored_dir = Path(compatible_path)
-        restored_config = json.loads(restored_dir.joinpath("config.json").read_text(encoding="utf-8"))
+        restored_config = json.loads(
+            restored_dir.joinpath("config.json").read_text(encoding="utf-8")
+        )
         assert restored_config["model_type"] == "llama"
         assert restored_config["architectures"] == ["LlamaForCausalLM"]
 
@@ -155,7 +166,8 @@ def test_maris_hf_compatible_path_returns_remote_snapshot_path_without_restore_a
         types.SimpleNamespace(
             snapshot_download=lambda **kwargs: (
                 str(snapshot_dir)
-                if kwargs["repo_id"] == "custom-user/plain-runtime" and kwargs["repo_type"] == "model"
+                if kwargs["repo_id"] == "custom-user/plain-runtime"
+                and kwargs["repo_type"] == "model"
                 else None
             )
         ),

core-python/tests/test_training_pipeline.py

@@ -292,6 +292,44 @@ def test_load_training_config_reads_optional_eval_dataset_repo(
     assert config.eval_dataset_repo == "MarisUK/maris-ai-evals"
 
 
+def test_load_training_config_reads_explicit_training_and_eval_dataset_repo_lists(
+    tmp_path: Path,
+) -> None:
+    config_path = tmp_path / "training.json"
+    config_path.write_text(
+        json.dumps(
+            {
+                "dataset_repo": "MarisUK/maris-ai-lv-memory",
+                "dataset_repos": [
+                    "MarisUK/maris-ai-memory",
+                    "MarisUK/maris-ai-lv-memory",
+                    "MarisUK/maris-ai-evals",
+                    "MarisUK/maris-ai-benchmark",
+                ],
+                "eval_dataset_repo": "MarisUK/maris-ai-evals",
+                "eval_dataset_repos": [
+                    "MarisUK/maris-ai-evals",
+                    "MarisUK/maris-ai-benchmark",
+                ],
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    config = load_training_config(str(config_path))
+
+    assert config.dataset_repos == [
+        "MarisUK/maris-ai-memory",
+        "MarisUK/maris-ai-lv-memory",
+        "MarisUK/maris-ai-evals",
+        "MarisUK/maris-ai-benchmark",
+    ]
+    assert config.eval_dataset_repos == [
+        "MarisUK/maris-ai-evals",
+        "MarisUK/maris-ai-benchmark",
+    ]
+
+
 def test_load_training_config_reads_benchmark_and_preference_paths(
     tmp_path: Path,
 ) -> None:
@@ -312,7 +350,7 @@ def test_load_training_config_reads_benchmark_and_preference_paths(
                 "branch_benchmark_targets": {"master": {"overall": 0.8, "reasoning": 0.78}},
                 "branch_benchmark_names": {
                     "master": "memory-quality",
-                    "coder": "coder-release-quality"
+                    "coder": "coder-release-quality",
                 },
                 "branch_benchmark_dataset_paths": {
                     "coder": "/tmp/benchmarks/coder-release.json",
@@ -388,7 +426,9 @@ def test_apply_branch_runtime_defaults_prefers_master_memory_suite() -> None:
     resolved = train_module._apply_branch_runtime_defaults(config)
 
     assert resolved.benchmark_name == "memory-quality"
-    assert resolved.benchmark_dataset_path.endswith("core-python/evals/master_memory_benchmark.json")
+    assert resolved.benchmark_dataset_path.endswith(
+        "core-python/evals/master_memory_benchmark.json"
+    )
 
 
 def test_build_benchmark_gate_artifact_uses_world_class_defaults_and_blocks_regressions() -> None:
@@ -1528,6 +1568,18 @@ def test_train_prefers_existing_local_artifact_when_continue_mode_enabled(
     output_dir = tmp_path / "continued-model"
     output_dir.mkdir(parents=True, exist_ok=True)
     (output_dir / "config.json").write_text("{}", encoding="utf-8")
+    import maris_core.training.train as train_module
+
+    (output_dir / "training-config.json").write_text(
+        json.dumps(
+            {
+                train_module.MODEL_SOURCE_FINGERPRINT_KEY: train_module._build_model_source_fingerprint(
+                    DEFAULT_TRAINING_BASE_MODEL
+                )
+            }
+        ),
+        encoding="utf-8",
+    )
     monkeypatch.setattr(
         "maris_core.training.train.load_hf_dataset",
         lambda _: {
@@ -1612,6 +1664,36 @@ def test_train_prefers_existing_local_artifact_when_continue_mode_enabled(
     assert captured_paths["model"] == str(output_dir)
 
 
+def test_train_does_not_auto_resume_from_incompatible_output_artifact(
+    tmp_path: Path, monkeypatch
+) -> None:
+    output_dir = tmp_path / "incompatible-output"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    (output_dir / "config.json").write_text("{}", encoding="utf-8")
+    import maris_core.training.train as train_module
+
+    (output_dir / "training-config.json").write_text(
+        json.dumps(
+            {
+                train_module.MODEL_SOURCE_FINGERPRINT_KEY: train_module._build_model_source_fingerprint(
+                    "meta-llama/Llama-3.2-3B-Instruct"
+                )
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    config = load_training_config(
+        overrides={
+            "output_dir": str(output_dir),
+            "model_name": "Qwen/Qwen2.5-1.5B-Instruct",
+            "continue_from_latest_artifact": True,
+        }
+    )
+
+    assert train_module._resolve_training_model_source(config) == "Qwen/Qwen2.5-1.5B-Instruct"
+
+
 def test_train_restores_maris_artifacts_after_push_to_hub(tmp_path: Path, monkeypatch) -> None:
     class FakeDataset:
         def __init__(self, items):
@@ -1949,7 +2031,7 @@ def test_export_model_publishes_branch_suite_to_runtime_repos(tmp_path: Path, mo
 
     suite_dir = tmp_path / "suite"
     suite_dir.mkdir()
-    for branch_name in ("master", "image", "tts"):
+    for branch_name in ("master", "coder", "image", "tts"):
         branch_dir = suite_dir / branch_name
         branch_dir.mkdir()
         branch_dir.joinpath("config.json").write_text("{}", encoding="utf-8")
@@ -1958,6 +2040,7 @@ def test_export_model_publishes_branch_suite_to_runtime_repos(tmp_path: Path, mo
             {
                 "branches": {
                     "master": {"output_dir": str(suite_dir / "master")},
+                    "coder": {"output_dir": str(suite_dir / "coder")},
                     "image": {"output_dir": str(suite_dir / "image")},
                     "tts": {"output_dir": str(suite_dir / "tts")},
                 }
@@ -2002,7 +2085,7 @@ def test_export_model_publishes_branch_suite_to_runtime_repos(tmp_path: Path, mo
         },
         {
             "create_repo": {
-                "repo_id": "MarisUK/maris-ai-text",
+                "repo_id": "MarisUK/maris-ai-lv",
                 "repo_type": "model",
                 "exist_ok": True,
             }
@@ -2010,11 +2093,26 @@ def test_export_model_publishes_branch_suite_to_runtime_repos(tmp_path: Path, mo
         {
             "upload_folder": {
                 "folder_path": str(suite_dir / "master"),
-                "repo_id": "MarisUK/maris-ai-text",
+                "repo_id": "MarisUK/maris-ai-lv",
                 "repo_type": "model",
                 "commit_message": "Maris AI model export (master)",
             }
         },
+        {
+            "create_repo": {
+                "repo_id": "MarisUK/maris-ai-codex",
+                "repo_type": "model",
+                "exist_ok": True,
+            }
+        },
+        {
+            "upload_folder": {
+                "folder_path": str(suite_dir / "coder"),
+                "repo_id": "MarisUK/maris-ai-codex",
+                "repo_type": "model",
+                "commit_message": "Maris AI model export (coder)",
+            }
+        },
         {
             "create_repo": {
                 "repo_id": "MarisUK/maris-ai-image",
@@ -2628,7 +2726,9 @@ def test_train_uses_external_eval_dataset_when_configured(tmp_path: Path, monkey
 
     metrics = train(
         output_dir=str(tmp_path / "trained-model"),
+        dataset_repos=["MarisUK/maris-ai-lv-memory"],
         eval_dataset_repo="MarisUK/maris-ai-evals",
+        eval_dataset_repos=["MarisUK/maris-ai-evals"],
     )
 
     assert metrics["eval_loss"] == 0.2
@@ -2638,6 +2738,147 @@ def test_train_uses_external_eval_dataset_when_configured(tmp_path: Path, monkey
     assert len(FakeTrainer.last_instance.eval_dataset) == 1
 
 
+def test_train_merges_multiple_dataset_repos_for_training_and_eval(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    dataset_calls: list[str] = []
+
+    class FakeSplit(list):
+        column_names = ["text"]
+
+        def map(self, function, **kwargs):
+            del kwargs
+            batch = {"text": [item["text"] for item in self]}
+            mapped = function(batch)
+            size = len(next(iter(mapped.values()))) if mapped else 0
+            return FakeSplit(
+                [{key: value[index] for key, value in mapped.items()} for index in range(size)]
+            )
+
+    repo_rows = {
+        "MarisUK/maris-ai-memory": {
+            "train": [{"text": "memory-train"}],
+            "validation": [{"text": "memory-val"}],
+        },
+        "MarisUK/maris-ai-lv-memory": {
+            "train": [{"text": "lv-train"}],
+            "validation": [{"text": "lv-val"}],
+        },
+        "MarisUK/maris-ai-evals": {
+            "train": [{"text": "eval-train"}],
+            "validation": [{"text": "eval-val"}],
+        },
+        "MarisUK/maris-ai-benchmark": {
+            "train": [{"text": "bench-train"}],
+            "validation": [{"text": "bench-val"}],
+        },
+    }
+
+    def fake_load_hf_dataset(repo_id: str):
+        dataset_calls.append(repo_id)
+        if repo_id not in repo_rows:
+            raise AssertionError(f"Unexpected repo id: {repo_id}")
+        payload = repo_rows[repo_id]
+        return {split_name: FakeSplit(list(records)) for split_name, records in payload.items()}
+
+    class FakeTokenizer:
+        pad_token = None
+        eos_token = "<eos>"
+        pad_token_id = None
+        eos_token_id = 7
+
+        @classmethod
+        def from_pretrained(cls, model_name):
+            del model_name
+            return cls()
+
+        def __call__(self, texts, **kwargs):
+            del kwargs
+            return {
+                "input_ids": [[index + 1] for index, _ in enumerate(texts)],
+                "attention_mask": [[1] for _ in texts],
+            }
+
+        def save_pretrained(self, output_dir):
+            Path(output_dir).mkdir(parents=True, exist_ok=True)
+            Path(output_dir, "tokenizer.json").write_text("{}", encoding="utf-8")
+
+    class FakeModel:
+        config = types.SimpleNamespace(pad_token_id=None)
+
+        @classmethod
+        def from_pretrained(cls, model_name):
+            del model_name
+            return cls()
+
+    class FakeTrainingArguments:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+    class FakeTrainer:
+        last_instance = None
+
+        def __init__(self, *, model, args, train_dataset, eval_dataset=None, data_collator=None):
+            del model, data_collator
+            self.args = args
+            self.train_dataset = train_dataset
+            self.eval_dataset = eval_dataset
+            FakeTrainer.last_instance = self
+
+        def train(self):
+            return types.SimpleNamespace(metrics={"train_loss": 0.1})
+
+        def evaluate(self):
+            return {"eval_loss": 0.2}
+
+        def save_model(self, output_dir):
+            Path(output_dir).mkdir(parents=True, exist_ok=True)
+            Path(output_dir, "model.bin").write_text("ok", encoding="utf-8")
+
+    monkeypatch.setattr("maris_core.training.train.load_hf_dataset", fake_load_hf_dataset)
+    monkeypatch.setitem(
+        sys.modules,
+        "transformers",
+        types.SimpleNamespace(
+            AutoModelForCausalLM=FakeModel,
+            AutoTokenizer=FakeTokenizer,
+            DataCollatorForLanguageModeling=lambda **kwargs: kwargs,
+            Trainer=FakeTrainer,
+            TrainingArguments=FakeTrainingArguments,
+        ),
+    )
+
+    metrics = train(
+        output_dir=str(tmp_path / "trained-model"),
+        dataset_repo="MarisUK/maris-ai-lv-memory",
+        dataset_repos=[
+            "MarisUK/maris-ai-memory",
+            "MarisUK/maris-ai-lv-memory",
+            "MarisUK/maris-ai-evals",
+            "MarisUK/maris-ai-benchmark",
+        ],
+        eval_dataset_repo="MarisUK/maris-ai-evals",
+        eval_dataset_repos=[
+            "MarisUK/maris-ai-evals",
+            "MarisUK/maris-ai-benchmark",
+        ],
+    )
+
+    assert metrics["eval_loss"] == 0.2
+    assert dataset_calls == [
+        "MarisUK/maris-ai-memory",
+        "MarisUK/maris-ai-lv-memory",
+        "MarisUK/maris-ai-evals",
+        "MarisUK/maris-ai-benchmark",
+        "MarisUK/maris-ai-evals",
+        "MarisUK/maris-ai-benchmark",
+    ]
+    assert FakeTrainer.last_instance is not None
+    assert len(FakeTrainer.last_instance.train_dataset) == 4
+    assert len(FakeTrainer.last_instance.eval_dataset) == 2
+
+
 def test_evaluate_with_config_prefers_external_eval_dataset(tmp_path: Path, monkeypatch) -> None:
     dataset_calls: list[str] = []
     trained_model_dir = tmp_path / "trained-model"
@@ -2751,6 +2992,7 @@ def test_evaluate_with_config_prefers_external_eval_dataset(tmp_path: Path, monk
         overrides={
             "output_dir": str(trained_model_dir),
             "eval_dataset_repo": "MarisUK/maris-ai-evals",
+            "eval_dataset_repos": ["MarisUK/maris-ai-evals"],
             "benchmark_dataset_path": str(tmp_path / "benchmark.json"),
             "benchmark_levels": ["ci"],
         }

huggingface_human_training_space/app.py

@@ -679,7 +679,7 @@ def _auto_training_request() -> SpaceTrainingRequest:
         "MARIS_SPACE_AUTO_TRAIN_CONTINUE_MODEL_PATH",
         "MARIS_TRAIN_CONTINUE_MODEL_PATH",
         "HF_TRAIN_CONTINUE_MODEL_PATH",
-        default=output_subdir,
+        default="",
     ).strip()
     model_name = get_env_any_or_default(
         "MARIS_HUMAN_TRAINING_AUTO_TRAIN_MODEL_NAME",