uclone-x 0.2.1__tar.gz → 0.2.2__tar.gz

{uclone_x-0.2.1 → uclone_x-0.2.2}/CHANGELOG.md

@@ -13,6 +13,95 @@ names does.
 Versions follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html). Each date is
 the date that version was published.
 
+## [0.2.2] - 2026-09-24
+
+### Added
+
+- `ucx install` and `ucx start` now save the model they set up as the default, so
+  `ucx run`, `ucx room`, `ucx loop`, `ucx acp` and `ucx a2a` use it without `--provider`
+  or `--model`, and say which saved model they are using (`ucx acp` and `ucx a2a` on
+  stderr). A model already saved, for example in the dashboard's Settings, is kept; when
+  it differs from the one setup just prepared, setup says both and how to switch. A
+  dashboard that was started with no model picks up a default saved later.
+- `ucx llm use <model>` (with `--provider` and `--base-url`) changes the saved default.
+  It is the same setting as the dashboard's Settings. Command-line flags and environment
+  variables such as `LLM_PROVIDER`, `OLLAMA_MODEL` or a provider's API key variable still
+  come first, and `ucx llm use` says when one of them is set and takes priority.
+- In Settings, the API key field for OpenAI, Anthropic and Gemini links to the page where
+  that provider issues keys, warns when a key does not look like one for the chosen
+  provider or confirms that its format is right, and removes spaces and one pair of quotes
+  from the ends of a pasted key.
+- `ucx key list` shows whether `GEMINI_API_KEY` (or `GOOGLE_API_KEY`),
+  `ANTHROPIC_API_KEY` and `OPENAI_API_KEY` are set. `ucx key setup` opens the provider's
+  key page and writes the key you paste to a `.env` file: the nearest one in this folder
+  or above it, looking no higher than the top of the enclosing git checkout, where it
+  creates one if none is found. Outside a git checkout, it creates one in this folder if
+  none is found above. UClone-X does not read that file itself; load it into your shell,
+  or enter the key in Settings, for the key to be used.
+- Every clone may load the skills approved for it, without `load_skill` in its tool list,
+  and Scout can read web pages as well as search.
+
+### Changed
+
+- Ollama requests now ask for a 16K-token context window, unless `context_limit` or
+  `OLLAMA_CONTEXT_LENGTH` sets another, instead of leaving the size to Ollama, whose own
+  default was 4K on the machine the README's figures come from. A clone's request with
+  tool results then fits. It costs memory: for `qwen3:8b`, about 1.8 GB more than a 4K
+  window (an estimate, not a measurement).
+- The built-in clones Scout, Pioneer, Guardian and Writer have rewritten instructions,
+  now written entirely in English; they still answer in the language you write in. With
+  a Qwen model, clones are also told not to use tools that change files or other state
+  for advice, brainstorming or general reasoning unless you ask for that change, to use
+  read-only search and inspection tools when an answer needs evidence from the workspace
+  or the web, and to answer in the language of the question. They are told that accuracy
+  requirements alone are no reason to decline a reasonable request, to follow your
+  instructions and style without imposing their own judgments, to give substantive
+  answers, and not to add moral lectures, unsolicited caveats or boilerplate disclaimers.
+- The conversation list shows compact times ("now", "5m", "1d", "2w"), and a row's
+  rename and delete buttons appear when you point at the row or move keyboard focus to
+  it, so titles have more room.
+
+### Fixed
+
+- Local image generation on an NVIDIA card now runs on the GPU in half precision, where
+  0.2.1 ran it on the CPU. The engine tries CUDA, then Apple's MPS, then the CPU;
+  `ucx media status` names the device it will use, and image results name the GPU.
+- When less than about 10 GB of GPU memory is free (an estimate), for example because
+  Ollama is keeping a model loaded on the same card, the image engine keeps SDXL's parts
+  in system memory, moves each onto the card only while it runs, and decodes the image in
+  tiles. This needs `accelerate`, which is now installed with the image engine. It is
+  slower and can still run out of memory; if it does, the image request fails with a
+  plain message and the memory is released, and when `accelerate` is missing the message
+  says how to add it.
+- Under WSL2, the free GPU memory used for that decision now counts memory held by other
+  processes (read with NVML or `nvidia-smi`), so the image engine switches to the
+  low-memory mode when another program holds the card. When neither can be read, it uses
+  the low-memory mode.
+- A model that Ollama cannot give tools to (for example `deepseek-r1:14b`) now ends the
+  turn with a short message naming the model and suggesting one that can use tools, such
+  as `qwen3:8b`, plus where to change it: `--model` for `ucx run`,
+  `ucx room retry <id> --model <model>` in a room, and Settings in the dashboard and in an
+  ACP client. The dashboard gives that remedy instead of offering a Retry that would fail
+  the same way.
+- The one-line install now offers the image engine, which the published package
+  includes; 0.2.1 skipped it. When the installer reports success but the engine's core
+  packages (Pillow, diffusers, torch and transformers) cannot be imported, it says so
+  instead of reporting the engine installed. That check does not cover `accelerate`.
+- Setting up Ollama runs its official installer up to 3 times when the download is cut
+  off, with a message between attempts. An attempt that runs out the 15-minute limit is
+  not repeated.
+- A saved API key is used only with the provider it was saved for, and changing provider
+  with `ucx llm use` keeps it.
+
+### Compatibility
+
+- `settings.json` written by 0.2.2 can carry `llm_api_key_provider`, which 0.2.1
+  ignores: 0.2.1 applies a saved API key to whichever provider is saved, and a Settings
+  save in 0.2.1 removes the field. 0.2.1's terminal commands also do not read the saved
+  default.
+- A conversation that contains a turn refused because its model cannot use tools records
+  a reason 0.2.1 does not know, so 0.2.1 may not open it.
+
 ## [0.2.1] - 2026-09-24
 
 ### Added

{uclone_x-0.2.1 → uclone_x-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: uclone-x
-Version: 0.2.1
+Version: 0.2.2
 Summary: Next-Generation Event-Driven AI Agent Core & High-Performance Collaboration Framework
 Author-email: Kenny Lim <kennylim@uclone.net>
 License-Expression: Apache-2.0
@@ -21,6 +21,7 @@ Requires-Dist: pydantic-settings>=2.2.0
 Requires-Dist: pydantic>=2.7.0
 Requires-Dist: pyyaml>=6.0.1
 Provides-Extra: all
+Requires-Dist: accelerate>=0.31.0; extra == 'all'
 Requires-Dist: anthropic>=0.25.0; extra == 'all'
 Requires-Dist: diffusers>=0.31.0; extra == 'all'
 Requires-Dist: fastapi>=0.110.0; extra == 'all'
@@ -71,6 +72,7 @@ Requires-Dist: anthropic>=0.25.0; extra == 'llm'
 Requires-Dist: google-genai>=0.1.0; extra == 'llm'
 Requires-Dist: openai>=1.25.0; extra == 'llm'
 Provides-Extra: media
+Requires-Dist: accelerate>=0.31.0; extra == 'media'
 Requires-Dist: diffusers>=0.31.0; extra == 'media'
 Requires-Dist: pillow>=10.0.0; extra == 'media'
 Requires-Dist: torch>=2.2.0; extra == 'media'

{uclone_x-0.2.1 → uclone_x-0.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "uclone-x"
-version = "0.2.1"
+version = "0.2.2"
 description = "Next-Generation Event-Driven AI Agent Core & High-Performance Collaboration Framework"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -101,8 +101,14 @@ ontology = [
 # `ucx media status` reporting ready for an engine that would fail on `import torch`.
 # The floors here are the same ones `IN_PROCESS_REQUIREMENTS` checks at runtime, so a
 # beginner who installs this extra and a beginner who follows the hint end up equivalent.
+#
+# `accelerate` is what `enable_model_cpu_offload` needs. It is not a runtime requirement
+# (MPS and CPU never offload, and a CUDA card with room loads the whole pipeline), so it is
+# not in `IN_PROCESS_REQUIREMENTS`; it is here so an NVIDIA card whose memory is shared
+# with a resident Ollama model can still run SDXL instead of running out of memory.
 media = [
     "pillow>=10.0.0",
+    "accelerate>=0.31.0",
     "diffusers>=0.31.0",
     "torch>=2.2.0",
     "transformers>=4.40.0",

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/__init__.py

@@ -1,5 +1,5 @@
 """UClone-X: Next-Generation Event-Driven AI Agent Core & Collaboration Framework."""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"
 __author__ = "Kenny Lim <kennylim@uclone.net>"
 __all__ = ["__version__"]

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/agent/base.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Final, Literal, cast
+from typing import Any, Final, Literal, TypeVar, cast
 
 from uclone_x.agent.grounding import describe, unsupported_specifics
 from uclone_x.agent.hooks import (
@@ -101,6 +101,7 @@ from uclone_x.errors import (
     LLMConnectorNotConfiguredError,
     LLMStreamInterruptedError,
     LLMTimeoutError,
+    ModelLacksToolSupportError,
     PathTraversalError,
     SessionMutationDuringTurnError,
     SessionStoreNotConfiguredError,
@@ -246,24 +247,61 @@ class _StreamProgress:
         return "".join(self.thinking_chunks) if self.thinking_chunks else None
 
 
-def _is_provider_timeout(exc: BaseException) -> bool:
-    """Whether a turn failed because a provider ran past the ceiling the caller set.
+_ChainedError = TypeVar("_ChainedError", bound=BaseException)
+
+
+def _in_cause_chain(exc: BaseException, kind: type[_ChainedError]) -> _ChainedError | None:
+    """The first exception of type `kind` in `exc`'s `__cause__` chain, `exc` included.
 
     The chain is walked rather than the exception tested directly, because the streaming
     path does not deliver the connector's error itself: `_invoke_model` raises
     `LLMStreamInterruptedError` with the provider's error chained as `__cause__`. Testing
-    only the outermost type would report a cut-off stream as an ordinary failure, which is
-    the distinction this function exists to make.
+    only the outermost type would report a cut-off stream as an ordinary failure.
     """
     seen = exc
     for _ in range(_MAX_CAUSE_DEPTH):
-        if isinstance(seen, LLMTimeoutError):
-            return True
+        if isinstance(seen, kind):
+            return seen
         cause = seen.__cause__
         if cause is None:
-            return False
+            return None
         seen = cause
-    return False
+    return None
+
+
+def _is_provider_timeout(exc: BaseException) -> bool:
+    """Whether a turn failed because a provider ran past the ceiling the caller set."""
+    return _in_cause_chain(exc, LLMTimeoutError) is not None
+
+
+def _model_lacking_tools(exc: BaseException) -> ModelLacksToolSupportError | None:
+    """The refusal of a model that cannot take tools, if that is why a turn failed.
+
+    The error the turn reports when it is found: its message is written for the user,
+    while the `LLMStreamInterruptedError` wrapping it names classes and a status line.
+    """
+    return _in_cause_chain(exc, ModelLacksToolSupportError)
+
+
+def _turn_failure(
+    exc: BaseException, stop_reason: TurnStopReason, agent_id: str
+) -> tuple[TurnStopReason, str]:
+    """The stop reason and `error` a turn that raised `exc` ends with, logged as it deserves.
+
+    A function of its own because `execute_turn` is at the edge of what the type checker
+    can analyse, and each branch added inline pushes it over.
+    """
+    if _is_provider_timeout(exc):
+        stop_reason = "provider_timeout"
+    lacking_tools = _model_lacking_tools(exc)
+    if lacking_tools is None:
+        logger.exception("Error executing turn for agent %s", agent_id)
+        return stop_reason, str(exc)
+    # A choice of model, not a fault in the code. With no handler set up, Python prints
+    # WARNING and above -- traceback included -- on the user's terminal, beside the plain
+    # sentence the CLI already shows.
+    logger.info("Turn for agent %s refused: %s", agent_id, lacking_tools)
+    return "model_without_tools", str(lacking_tools)
 
 
 class _AnchorWriter(Enum):
@@ -4530,9 +4568,7 @@ class BaseAgent(BaseAgentProtocol):
                 # Named before anything else reads it. `error` carries the same fact as
                 # prose, and prose is not something a caller can branch on without
                 # guessing at a provider's wording (#1277).
-                if _is_provider_timeout(exc):
-                    stop_reason = "provider_timeout"
-                logger.exception("Error executing turn for agent %s", self.agent_id)
+                stop_reason, failure = _turn_failure(exc, stop_reason, self.agent_id)
                 req_model = self._config.llm_config.model_name
 
                 # Execute ON_ERROR hook
@@ -4626,7 +4662,7 @@ class BaseAgent(BaseAgentProtocol):
                     tool_executions=tuple(tool_executions),  # ran before the failure
                     tool_executions_complete=not tools_unreported,  # a failure mid-step
                     is_completed=False,
-                    error=str(exc),
+                    error=failure,
                     stop_reason=stop_reason,
                     correlation_id=correlation_id,
                     provenance=failover_provenance,

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/agent/models.py

@@ -116,6 +116,7 @@ BASE_PERSONA_TOOLS: tuple[str, ...] = (
     "file_search",
     "directory_list",
     "tool_result_read",
+    "load_skill",
 )
 
 
@@ -440,6 +441,7 @@ TurnStopReason = Literal[
     "step_results_over_window",
     "budget_exceeded",
     "provider_timeout",
+    "model_without_tools",
     "cancelled",
 ]
 """How a turn's step run ended: the vocabulary of `TURN_END.stop_reason` and `TurnResult`.
@@ -458,6 +460,11 @@ connector's ceiling and a probe whose host was not running both reached the repo
 distribution. A consumer that must not count a cut-off turn as the model's failure needs
 a field it can test, not a phrase it can grep. It is not a refusal -- `turn_refusal`
 leaves it `None` -- because a retry at a longer ceiling is exactly the right response.
+
+`model_without_tools` is a provider's refusal of the chosen model because it cannot take
+tool definitions, which every clone turn sends. Its `error` is a plain sentence naming the
+model and the remedy, written to be shown as is. It is a refusal: a retry on the same model
+is refused the same way, so `turn_refusal` maps it to `RoomTurnRefusal.MODEL_WITHOUT_TOOLS`.
 """
 
 

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/agent/prompts.py

@@ -203,11 +203,26 @@ HERMES_STEERABILITY_POLICY: Final[str] = (
     "and respond naturally in the language in which the user communicates."
 )
 
+QWEN_STEERABILITY_POLICY: Final[str] = (
+    "For Qwen runtime models, accuracy constraints govern precision and tool routing; on their own they are not a reason "
+    "to decline an otherwise reasonable request. "
+    "Tool Calling Discipline: Do not invoke file modification or state-changing action tools for conversational advice, brainstorming, or general reasoning. "
+    "Actively use read-only search and inspection tools when grounded evidence from the workspace or web is required, and invoke modification tools only when explicitly commanded. "
+    "Language Matching: Always respond fluently and consistently in the exact language used by the user's prompt. "
+    "Respect User Agency: Treat the user as an autonomous decision-maker, and follow their "
+    "instructions and style requests without imposing personal or ideological judgments. "
+    "Substantive Answers: Provide detailed, substantive answers that directly address the prompt. "
+    "No Moralizing: Do not add patronizing commentary, moral lectures, unsolicited caveats, or boilerplate disclaimers. "
+    "Tone Adaptation: Match the tone, intensity, and creative or stylistic direction requested by the user, "
+    "and respond naturally in the language in which the user communicates."
+)
+
 #: Families whose framing departs from `STEERABILITY_POLICY`. A family absent from this
 #: mapping gets the default — that is a declared fallback, not a silent one, and
 #: `steerability_policy_for` is the single place it is resolved.
 _FAMILY_STEERABILITY: Final[Mapping[ModelFamily, str]] = {
     ModelFamily.HERMES: HERMES_STEERABILITY_POLICY,
+    ModelFamily.QWEN: QWEN_STEERABILITY_POLICY,
 }
 
 
@@ -306,6 +321,7 @@ __all__ = [
     "HONEST_REPORTING",
     "IDENTITY_GROUNDING",
     "IMAGE_GENERATION",
+    "QWEN_STEERABILITY_POLICY",
     "STEERABILITY_POLICY",
     "TASK_CAPABILITIES",
     "CapabilityFragment",

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/cli/commands/a2a.py

@@ -82,11 +82,15 @@ def start_a2a_server(
     from uclone_x.agent.composition import HostDependencies, compose_agent
     from uclone_x.agent.session import SessionStore
     from uclone_x.cli.agent_memory import memory_for_agent_id
-    from uclone_x.llm.connectors.factory import create_llm_connector
+    from uclone_x.llm.connectors.factory import create_llm_connector, saved_choice_notice
     from uclone_x.shells.a2a_server import A2AServer
     from uclone_x.telemetry import TelemetryTracer
     from uclone_x.tools.registry import create_default_registry
 
+    saved_notice = saved_choice_notice()
+    if saved_notice is not None:
+        # stderr, as ACP does: what the server says to its caller stays on its own channel.
+        Console(stderr=True).print(saved_notice, markup=False, highlight=False)
     llm = create_llm_connector(fallback_to_mock=True)
     memory = memory_for_agent_id(agent_config.agent_id)
 

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/cli/commands/acp.py

@@ -18,7 +18,7 @@ from uclone_x.agent.persona_store import DEFAULT_PERSONA_NAME
 from uclone_x.agent.session import SessionStore
 from uclone_x.cli.agent_memory import memory_for_agent_id
 from uclone_x.engine.event_bus import EventBus
-from uclone_x.llm.connectors.factory import create_llm_connector
+from uclone_x.llm.connectors.factory import create_llm_connector, saved_choice_notice
 from uclone_x.shells.acp import ACPServer
 from uclone_x.shells.acp.server import SessionAgentFactory
 from uclone_x.telemetry import TelemetryTracer
@@ -30,6 +30,8 @@ acp_app = typer.Typer(
     no_args_is_help=True,
 )
 console = Console()
+# ACP speaks over stdout, so anything said to the person goes to stderr.
+err_console = Console(stderr=True)
 
 
 def session_agent_factory(config: AgentConfig, host: HostDependencies) -> SessionAgentFactory:
@@ -80,6 +82,9 @@ def start_acp_server(agent_id: str | None = None, persona: str = DEFAULT_PERSONA
     agent_config = agent_config_for_persona(persona_def, agent_id=agent_id)
 
     bus = EventBus()
+    saved_notice = saved_choice_notice()
+    if saved_notice is not None:
+        err_console.print(saved_notice, markup=False, highlight=False)
     llm = create_llm_connector(fallback_to_mock=True)
     store = SessionStore()
     tracer = TelemetryTracer()

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/cli/commands/bootstrap.py

@@ -370,6 +370,24 @@ def ollama_installer_env() -> dict[str, str]:
     return env
 
 
+#: How many times the official Ollama installer is run before giving up. Its download is
+#: a single ~1 GB archive with no resume, and a reset connection at 95% (measured on a Mac
+#: on a flaky network: `curl: (56) Recv failure: Connection reset by peer`) otherwise
+#: ends the whole setup at "not runnable".
+OLLAMA_INSTALL_ATTEMPTS: Final = 3
+#: Seconds to wait before running the installer again, multiplied by the attempt number.
+OLLAMA_INSTALL_RETRY_DELAY_S: float = 5.0
+
+
+def _ollama_runnable() -> tuple[str, str] | None:
+    """``(binary, version)`` when an ollama can be found and run, else ``None``."""
+    binary = ollama_binary()
+    version = ollama_version(binary)
+    if binary is None or version is None:
+        return None
+    return binary, version
+
+
 def install_ollama_platform() -> bool:
     """Install Ollama, then verify by running it — never by trusting the exit code.
 
@@ -380,30 +398,50 @@ def install_ollama_platform() -> bool:
     on the measured Mac mini (its `sudo ln` fails) while leaving a perfectly usable app
     behind, so exit code and reality disagree in both directions and only one of them can
     be measured.
+
+    The official installer is run up to ``OLLAMA_INSTALL_ATTEMPTS`` times while the binary
+    is still not runnable afterwards, because the usual cause is a download cut off part
+    way. A run that hits the 15-minute timeout is not repeated: another 15 minutes on the
+    same connection is not a remedy, and the person has already waited.
     """
     os_type = platform.system()
     if os_type == "Darwin" and shutil.which("brew"):
         console.print("[bold cyan]📦 Installing Ollama via Homebrew...[/bold cyan]")
         subprocess.run(["brew", "install", "ollama"], check=False, stdin=subprocess.DEVNULL)
+        found = _ollama_runnable()
     elif os_type in ("Darwin", "Linux"):
-        console.print("[bold cyan]📦 Installing Ollama via official install script...[/bold cyan]")
-        try:
-            subprocess.run(
-                "curl -fsSL https://ollama.com/install.sh | sh",
-                shell=True,
-                check=False,
-                stdin=subprocess.DEVNULL,
-                env=ollama_installer_env(),
-                timeout=900,
-            )
-        except subprocess.TimeoutExpired:
+        found = None
+        for attempt in range(1, OLLAMA_INSTALL_ATTEMPTS + 1):
+            if attempt == 1:
+                console.print(
+                    "[bold cyan]📦 Installing Ollama via official install script...[/bold cyan]"
+                )
+            try:
+                subprocess.run(
+                    "curl -fsSL https://ollama.com/install.sh | sh",
+                    shell=True,
+                    check=False,
+                    stdin=subprocess.DEVNULL,
+                    env=ollama_installer_env(),
+                    timeout=900,
+                )
+            except subprocess.TimeoutExpired:
+                console.print(
+                    "[bold red]✖ The Ollama installer did not finish in 15 minutes.[/bold red]"
+                )
+                return False
+            except Exception as exc:
+                console.print(f"[bold red]✖ Could not run the Ollama installer: {exc}[/bold red]")
+                return False
+            found = _ollama_runnable()
+            if found is not None or attempt == OLLAMA_INSTALL_ATTEMPTS:
+                break
             console.print(
-                "[bold red]✖ The Ollama installer did not finish in 15 minutes.[/bold red]"
+                f"[yellow]The Ollama download did not finish, which usually means the "
+                f"connection dropped. Trying again ({attempt + 1} of "
+                f"{OLLAMA_INSTALL_ATTEMPTS})...[/yellow]"
             )
-            return False
-        except Exception as exc:
-            console.print(f"[bold red]✖ Could not run the Ollama installer: {exc}[/bold red]")
-            return False
+            time.sleep(OLLAMA_INSTALL_RETRY_DELAY_S * attempt)
     else:
         console.print(
             f"[bold red]✖ No automated Ollama install for {escape(os_type)}. "
@@ -411,14 +449,13 @@ def install_ollama_platform() -> bool:
         )
         return False
 
-    binary = ollama_binary()
-    version = ollama_version(binary)
-    if binary is None or version is None:
+    if found is None:
         console.print(
             "[bold red]✖ Ollama is still not runnable after the install.[/bold red] "
             "Looked on PATH and at " + escape(", ".join(OLLAMA_APP_BINARIES)) + "."
         )
         return False
+    binary, version = found
     console.print(f"[bold green]✔ Ollama ready:[/bold green] {escape(binary)} ({escape(version)})")
     return True
 
@@ -675,9 +712,9 @@ def diffusers_install_command() -> list[str] | None:
     that stops at `diffusers` leaves the engine unable to generate (#1095).
     """
     from uclone_x.core.environment_install import installer_command
-    from uclone_x.tools.builtin.image import IN_PROCESS_REQUIREMENTS
+    from uclone_x.tools.builtin.image import IN_PROCESS_INSTALL_REQUIREMENTS
 
-    packages = [requirement for _, requirement, _ in IN_PROCESS_REQUIREMENTS]
+    packages = [requirement for _, requirement, _ in IN_PROCESS_INSTALL_REQUIREMENTS]
     return installer_command(*packages)
 
 
@@ -1223,6 +1260,76 @@ class LocalSetupResult(NamedTuple):
         return [part.summary_line() for part in (self.llm, self.image) if part is not None]
 
 
+def _same_address(saved: str | None, prepared: str | None) -> bool:
+    """Whether a saved Ollama address reaches the daemon setup prepared.
+
+    No saved address means the connector resolves the usual one, which is the one setup
+    checked, so it counts as the same.
+    """
+    if saved is None or prepared is None:
+        return True
+    return saved.rstrip("/") == prepared.rstrip("/")
+
+
+def remember_local_llm(result: LlmSetup) -> None:
+    """Save the model setup just made ready as the default, unless one is already saved.
+
+    Without this, `ucx install --yes` printed `setup llm: ready model=...` and the next
+    `ucx run` refused with "No LLM provider is configured": nothing setup did was anywhere
+    the terminal commands looked. The choice goes to the file the dashboard's Settings
+    already keep, so there is one saved choice for every head. A choice already saved --
+    by the person in Settings, or by an earlier install -- is kept; setup only fills in
+    what is missing.
+
+    What is printed is read back from the file after the write, not assumed from it: when
+    the saved default is not what setup just prepared, the person is told both, and how to
+    switch. A failure to save is reported and does not fail the setup: the model is still
+    ready, and `--provider`/`--model` or the dashboard still reach it.
+    """
+    from uclone_x.llm.connectors.saved_choice import read_saved_choice, remember_choice_if_unset
+
+    model = escape(result.model)
+    try:
+        written, _before = remember_choice_if_unset(
+            provider="ollama", model=result.model, base_url=result.endpoint
+        )
+        saved = read_saved_choice()
+    except (OSError, ValueError):
+        console.print(
+            "[yellow]Could not save this model as the default, so `ucx run` will not pick "
+            "it up on its own. Choose it in the dashboard's Settings, or pass "
+            f"--provider ollama --model {model}.[/yellow]"
+        )
+        return
+    if saved is None:
+        return
+    switch = (
+        f"To use {model} instead, run `ucx llm use {model}` or choose it in the "
+        "dashboard's Settings."
+    )
+    if saved.provider != "ollama" or saved.model not in (None, result.model):
+        what = escape(saved.model or saved.provider)
+        if saved.provider != "ollama":
+            what = f"{what} ({escape(saved.provider)})"
+        console.print(
+            f"[yellow]{what} is already saved as the default model, so it stays the "
+            f"default rather than {model}, which setup just prepared. {switch}[/yellow]"
+        )
+    elif not _same_address(saved.base_url, result.endpoint):
+        console.print(
+            f"[yellow]The saved default asks for {model} at {escape(saved.base_url or '')}, "
+            f"but setup prepared it at {escape(result.endpoint)}. To use this one, run "
+            f"`ucx llm use {model} --base-url {escape(result.endpoint)}`.[/yellow]"
+        )
+    elif written:
+        console.print(
+            f"[green]✔ Saved {model} as the default model for `ucx run`, "
+            "rooms and the dashboard.[/green]"
+        )
+    else:
+        console.print(f"[dim]Kept {model}, the model already saved as the default.[/dim]")
+
+
 def run_local_setup(
     *,
     llm: bool = True,
@@ -1238,8 +1345,11 @@ def run_local_setup(
     copy of this sequence inline; two copies of "prepare the local models" is how one of
     them silently stops matching the other.
     """
+    llm_result = setup_local_llm(interactive=interactive, assume_yes=assume_yes) if llm else None
+    if llm_result is not None and llm_result.ready:
+        remember_local_llm(llm_result)
     return LocalSetupResult(
-        llm=(setup_local_llm(interactive=interactive, assume_yes=assume_yes) if llm else None),
+        llm=llm_result,
         image=(
             setup_local_image(
                 interactive=interactive,

{uclone_x-0.2.1 → uclone_x-0.2.2}/src/uclone_x/cli/commands/eval.py

@@ -124,7 +124,9 @@ def eval_run(
     ] = "all",
     model: Annotated[
         str | None,
-        typer.Option("--model", "-m", help="Target model identifier override (e.g. qwen3:1.7b)"),
+        typer.Option(
+            "--model", "-m", help="Target model identifier override (e.g. qwen3:8b, hermes3:8b)"
+        ),
     ] = None,
     provider: Annotated[
         str | None,