localcode 0.3.44__tar.gz → 0.3.46__tar.gz

{localcode-0.3.44/src/localcode.egg-info → localcode-0.3.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.44
+Version: 0.3.46
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -135,13 +135,14 @@ On launch, LocalCode recommends the best model for **your Mac's RAM** — there'
 | Gemma 4 26B-A4B | 11.2 GB (Q3) | 3.8B (8/128 experts) | 24 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 10.7 GB (Q2) | 3.0B (8+1/256) | 24 GB | qwen35moe |
 | Qwen 3.8 27B | 17.9 GB (Q4) | 27B (dense) | 32 GB | qwen35 |
+| Muse Glimmer 30B † | 15.9 GB (Q4) | 30B (dense, multimodal) | 32 GB | muse_glimmer |
 | DiffusionGemma 26B-A4B † | 15.7 GB (Q4) | 4B (diffusion MoE) | 32 GB | diffusion_gemma |
 | North-Mini-Code 30B-A3B † | 17.9 GB (Q4) | 3B (30B MoE) | 36 GB | cohere2_moe |
 | Gemma 4 12B (full) | 23.8 GB (BF16) | 12B (dense) | 48 GB | gemma4-iswa |
 | Gemma 4 26B-A4B | 28 GB (Q8) | 3.8B (8/128 experts) | 64 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 38.5 GB (Q8) | 3.0B (8+1/256) | 96 GB | qwen35moe |
 
-*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended (DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack).
+*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended. DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack; Muse Glimmer's `muse_glimmer` arch isn't in the TurboQuant server, so LocalCode builds a dedicated stock llama-server (llama.cpp PR #26841) on first use and serves it without TurboQuant KV compression.
 
 ## How LocalCode works
 

{localcode-0.3.44 → localcode-0.3.46}/README.md

@@ -88,13 +88,14 @@ On launch, LocalCode recommends the best model for **your Mac's RAM** — there'
 | Gemma 4 26B-A4B | 11.2 GB (Q3) | 3.8B (8/128 experts) | 24 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 10.7 GB (Q2) | 3.0B (8+1/256) | 24 GB | qwen35moe |
 | Qwen 3.8 27B | 17.9 GB (Q4) | 27B (dense) | 32 GB | qwen35 |
+| Muse Glimmer 30B † | 15.9 GB (Q4) | 30B (dense, multimodal) | 32 GB | muse_glimmer |
 | DiffusionGemma 26B-A4B † | 15.7 GB (Q4) | 4B (diffusion MoE) | 32 GB | diffusion_gemma |
 | North-Mini-Code 30B-A3B † | 17.9 GB (Q4) | 3B (30B MoE) | 36 GB | cohere2_moe |
 | Gemma 4 12B (full) | 23.8 GB (BF16) | 12B (dense) | 48 GB | gemma4-iswa |
 | Gemma 4 26B-A4B | 28 GB (Q8) | 3.8B (8/128 experts) | 64 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 38.5 GB (Q8) | 3.0B (8+1/256) | 96 GB | qwen35moe |
 
-*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended (DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack).
+*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended. DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack; Muse Glimmer's `muse_glimmer` arch isn't in the TurboQuant server, so LocalCode builds a dedicated stock llama-server (llama.cpp PR #26841) on first use and serves it without TurboQuant KV compression.
 
 ## How LocalCode works
 

{localcode-0.3.44 → localcode-0.3.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.44"
+version = "0.3.46"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.3.44"
+    __version__ = "0.3.46"

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/bootstrap.py

@@ -1239,6 +1239,97 @@ def ensure_cohere_server(
         return False, f"cohere server build failed: {e}"
 
 
+# ── Muse Glimmer server (Meta Muse-Glimmer-30B) ─────────────────────
+#
+# The TurboQuant llama-server doesn't have Meta's muse_glimmer architecture.
+# Upstream llama.cpp added it in PR #26841 (merged 2026-08-10, first shipped in
+# release b10353), so — exactly like the cohere2moe and diffusion runners — we
+# build a stock llama-server from current master ONCE and cache it. Muse Glimmer
+# is an ordinary autoregressive multimodal model, served over the normal HTTP
+# path with stock (non-TurboQuant) flags; it just needs a binary with the arch
+# compiled in. Master is well past b10353, so the arch is present.
+_MUSE_BIN_NAME = "llama-server-muse"
+
+
+def muse_server_path(config=None) -> Path | None:
+    """Locate an existing muse_glimmer-capable llama-server binary, or None."""
+    if config is not None:
+        p = (getattr(config.runtime, "muse_server_binary", "") or "").strip()
+        if p and Path(p).is_file():
+            return Path(p)
+    cached = Path.home() / ".local" / "share" / "localcode" / _MUSE_BIN_NAME
+    if cached.is_file():
+        return cached
+    return None
+
+
+def ensure_muse_server(
+    on_progress: Callable[[str], None] | None = None,
+) -> tuple[bool, str]:
+    """Build (once) and cache a llama-server with muse_glimmer support.
+
+    Returns (ok, binary_path_or_error). Idempotent — short-circuits if a
+    cached binary exists. First build is several minutes of cmake.
+    """
+    existing = muse_server_path()
+    if existing is not None:
+        return True, str(existing)
+
+    def _say(msg: str) -> None:
+        if on_progress:
+            on_progress(msg)
+
+    if not shutil.which("git"):
+        return False, "git is required to build the Muse Glimmer server (xcode-select --install)."
+    if not _ensure_cmake():
+        return False, "cmake is required to build the Muse Glimmer server (brew install cmake)."
+
+    data_dir = Path.home() / ".local" / "share" / "localcode"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    src = data_dir / "llama.cpp-muse"
+
+    def _run(cmd: list[str], cwd: Path | None, timeout: int) -> tuple[bool, str]:
+        r = subprocess.run(cmd, cwd=str(cwd) if cwd else None,
+                           capture_output=True, text=True, timeout=timeout, check=False)
+        if r.returncode != 0:
+            tail = (r.stderr or r.stdout or "").strip().splitlines()[-8:]
+            return False, "\n".join(tail)
+        return True, ""
+
+    try:
+        if not (src / "CMakeLists.txt").is_file():
+            _say("Fetching llama.cpp (Muse Glimmer support, one-time)...")
+            shutil.rmtree(src, ignore_errors=True)
+            # master is past b10353 (PR #26841), so it has the muse_glimmer arch.
+            ok, err = _run(["git", "clone", "--depth", "1", _DIFFUSION_LLAMA_REPO, str(src)],
+                           cwd=None, timeout=600)
+            if not ok:
+                return False, f"git clone failed:\n{err}"
+
+        _say("Building llama-server with muse_glimmer (one-time, ~5-12 min)...")
+        ok, err = _run(["cmake", "-B", "build", "-DCMAKE_BUILD_TYPE=Release",
+                        "-DGGML_METAL=ON", "-DLLAMA_CURL=OFF"], cwd=src, timeout=600)
+        if not ok:
+            return False, f"cmake configure failed:\n{err}"
+        ok, err = _run(["cmake", "--build", "build", "-j", "--config", "Release",
+                        "--target", "llama-server"], cwd=src, timeout=3600)
+        if not ok:
+            return False, f"cmake build failed:\n{err}"
+
+        built = src / "build" / "bin" / "llama-server"
+        if not built.is_file():
+            return False, f"build finished but {built} is missing."
+        dest = data_dir / _MUSE_BIN_NAME
+        shutil.copyfile(built, dest)
+        dest.chmod(0o755)
+        _say("Muse Glimmer server ready.")
+        return True, str(dest)
+    except subprocess.TimeoutExpired as e:
+        return False, f"build step timed out: {' '.join(map(str, e.cmd))}"
+    except Exception as e:
+        return False, f"Muse Glimmer server build failed: {e}"
+
+
 def build_turboquant(on_progress: Callable[[str], None] | None = None) -> tuple[bool, str]:
     """Build the TurboQuant llama.cpp fork from source with Metal support."""
     source = _find_turboquant_source()

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/config.py

@@ -120,6 +120,7 @@ class RuntimeConfig:
     llama_cpp_binary: str = ""             # custom llama-server path (e.g. TurboQuant fork)
     diffusion_cli_binary: str = ""         # llama-diffusion-cli path (DiffusionGemma runner; built on demand)
     cohere_server_binary: str = ""         # llama-server with cohere2moe (North-Mini-Code; built on demand from PR #24260)
+    muse_server_binary: str = ""           # llama-server with muse_glimmer (Meta Muse Glimmer; built on demand from llama.cpp master, PR #26841)
     model_dir: str = ""                    # directory where GGUFs download to (blank → ~/.local/share/localcode/models)
     # Vision toggle. Tracks whether the multimodal projector should be
     # loaded (--mmproj) alongside the text decoder. Persisted so turning
@@ -252,6 +253,7 @@ def save_config(config: AppConfig) -> Path:
         f"llama_cpp_cache_reuse = {config.runtime.llama_cpp_cache_reuse}\n"
         f'diffusion_cli_binary = "{config.runtime.diffusion_cli_binary}"\n'
         f'cohere_server_binary = "{config.runtime.cohere_server_binary}"\n'
+        f'muse_server_binary = "{config.runtime.muse_server_binary}"\n'
         f'model_dir = "{config.runtime.model_dir}"\n'
         f"vision_enabled = {'true' if config.runtime.vision_enabled else 'false'}\n"
         f"temperature = {config.runtime.temperature}\n"
@@ -335,6 +337,7 @@ def load_config() -> AppConfig:
         llama_cpp_cache_reuse=int(os.environ.get("LOCALCODE_LLAMA_CPP_CACHE_REUSE", runtime_data.get("llama_cpp_cache_reuse", 256))),
         diffusion_cli_binary=os.environ.get("LOCALCODE_DIFFUSION_CLI_BINARY", runtime_data.get("diffusion_cli_binary", "")),
         cohere_server_binary=os.environ.get("LOCALCODE_COHERE_SERVER_BINARY", runtime_data.get("cohere_server_binary", "")),
+        muse_server_binary=os.environ.get("LOCALCODE_MUSE_SERVER_BINARY", runtime_data.get("muse_server_binary", "")),
         model_dir=os.environ.get("LOCALCODE_MODEL_DIR", runtime_data.get("model_dir", "")),
         vision_enabled=str(os.environ.get("LOCALCODE_VISION_ENABLED", runtime_data.get("vision_enabled", False))).lower() in {"1", "true", "yes", "on"},
         # `llama_cpp_spec_type` migration (2026-04-26): old configs

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/models_catalog.py

@@ -293,6 +293,32 @@ CHOICES: list[ModelChoice] = [
         ),
         reasoning_budget_tokens=0,
     ),
+    ModelChoice(
+        key="muse-glimmer",
+        name="Muse Glimmer 30B (Q4)",
+        hf_repo="unsloth/Muse-Glimmer-30B-GGUF",
+        filename="Muse-Glimmer-30B-UD-Q4_K_XL.gguf",
+        size_gb=15.9,
+        active_params="30B dense (+ perception encoder for vision)",
+        architecture="muse_glimmer",
+        license="Apache 2.0",
+        humaneval_pass_at_1=None,
+        notes=(
+            "Meta's Muse Glimmer 30B (Meta Superintelligence Lab, Aug 2026) — a "
+            "multimodal agentic model purpose-built for local deployment: multi-step "
+            "reasoning, tool use, failure recovery, and vision in one model. Unsloth "
+            "Dynamic UD-Q4_K_XL quant. Its muse_glimmer arch isn't in the TurboQuant "
+            "server, so LocalCode builds a dedicated stock llama-server from current "
+            "llama.cpp (PR #26841) on first use (one-time, ~5-12 min) and serves it "
+            "with stock flags + --jinja (required by its chat template). Pair with the "
+            "BF16 perception encoder for image input. ~15.9 GiB; recommend 32 GB+ "
+            "unified memory."
+        ),
+        mmproj_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+        mmproj_size_gb=3.85,
+        mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+        reasoning_budget_tokens=0,
+    ),
     ModelChoice(
         key="gemma-q8",
         name="Gemma 4 26B-A4B (Q8)",
@@ -367,7 +393,7 @@ def _system_ram_gb() -> int:
 # Architectures we never AUTO-recommend (users can still pick them explicitly in
 # the model picker): diffusion needs a separate one-shot runner — not the
 # standard llama-server — and cohere2_moe is unvalidated on this stack.
-_NO_AUTO_RECOMMEND_ARCHS = {"diffusion_gemma", "cohere2_moe"}
+_NO_AUTO_RECOMMEND_ARCHS = {"diffusion_gemma", "cohere2_moe", "muse_glimmer"}
 
 # Capability order for auto-recommend, best → worst for coding-agent use. This
 # is deliberately NOT raw file size: the big MoEs measure ~95% HumanEval here
@@ -608,6 +634,27 @@ MODEL_GROUPS: list[ModelGroup] = [
             "use and serves it with stock flags. 256K context. Text-only."
         ),
     ),
+    ModelGroup(
+        key="muse-glimmer-30b",
+        display_name="Muse Glimmer 30B",
+        maker="Meta",
+        hf_repo="unsloth/Muse-Glimmer-30B-GGUF",
+        family="muse",
+        architecture="muse_glimmer",
+        license="Apache 2.0",
+        notes=(
+            "Meta's multimodal agentic model for local deployment (Meta "
+            "Superintelligence Lab, Aug 2026): multi-step reasoning, tool use, "
+            "failure recovery, native vision. Unsloth Dynamic quants. Its "
+            "muse_glimmer arch isn't in the TurboQuant server — LocalCode builds a "
+            "dedicated stock llama-server from llama.cpp PR #26841 on first use and "
+            "serves it with stock flags + --jinja. Pair with the BF16 perception "
+            "encoder for image input."
+        ),
+        mmproj_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+        mmproj_size_gb=3.85,
+        mmproj_hf_filename="mmproj-Muse-Glimmer-30B-BF16.gguf",
+    ),
     ModelGroup(
         key="diffusiongemma-26b-a4b",
         display_name="DiffusionGemma 26B-A4B",

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/runtime.py

@@ -402,6 +402,43 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # No cohere binary yet — fall through; setup builds it on select,
             # and _restart_server surfaces a clear error if it's truly missing.
 
+        # ── muse_glimmer (Meta Muse Glimmer 30B) ──────────────────────
+        # The TurboQuant fork doesn't have Meta's muse_glimmer arch; LocalCode
+        # builds a dedicated stock llama-server from llama.cpp master (PR
+        # #26841). Stock binary → STOCK flags only (no turbo4 KV / -fit /
+        # --ctx-checkpoints). The model card is explicit that `--jinja` is
+        # mandatory (its chat template drives tool calls and the <|eom|> stop
+        # handling). Multimodal: pass --mmproj when vision is on and the
+        # perception encoder is present on disk.
+        if "muse" in _arch:
+            from .bootstrap import muse_server_path
+            mbin = (self.config.muse_server_binary or "").strip()
+            if not (mbin and _P(mbin).is_file()):
+                found = muse_server_path()
+                mbin = str(found) if found else ""
+            if mbin:
+                cmd = [
+                    mbin,
+                    "--model", model_path,
+                    "--port", str(port),
+                    "--ctx-size", str(self._target_num_ctx(model_path=model_path)),
+                    "--threads", str(threads),
+                    "--flash-attn", "on",
+                    "--mmap", "-ngl", "999",
+                    "--jinja",
+                    "-b", "512", "-ub", "512",
+                ]
+                try:
+                    if getattr(self.config, "vision_enabled", False):
+                        from .models_catalog import by_filename as _bf_muse
+                        _mc = _bf_muse(_P(model_path).name)
+                        if _mc is not None and _mc.mmproj_path and _mc.mmproj_path.is_file():
+                            cmd.extend(["--mmproj", str(_mc.mmproj_path)])
+                except Exception:
+                    pass
+                return cmd
+            # No muse binary yet — fall through; setup builds it on select.
+
         # ── Vanilla / stock llama.cpp compatibility (Linux CI, no Metal) ──
         # The bundled server is a TurboQuant fork whose flags (turbo4 KV,
         # -fit, --ctx-checkpoints, --spec-type) stock llama.cpp rejects.

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/tui/screens/chat.py

@@ -3328,6 +3328,22 @@ class ChatScreen(Screen):
                         f"Couldn't build the cohere2moe server: {res}")
                     return
                 engine.config.cohere_server_binary = res
+            # muse_glimmer (Meta Muse Glimmer): same story — the TurboQuant
+            # binary lacks the arch, so build the dedicated stock server on an
+            # in-chat /model swap that bypasses the setup screen.
+            if "muse" in _arch:
+                from ...bootstrap import ensure_muse_server
+                self.app.call_from_thread(
+                    self._set_download_line, "Building Muse Glimmer server (one-time)…")
+                ok, res = ensure_muse_server(
+                    on_progress=lambda m: self.app.call_from_thread(self._set_download_line, m))
+                self.app.call_from_thread(self._clear_download_line)
+                if not ok:
+                    self.app.call_from_thread(
+                        self._on_server_restart_failed,
+                        f"Couldn't build the Muse Glimmer server: {res}")
+                    return
+                engine.config.muse_server_binary = res
             # _restart_server now returns the healthcheck result that
             # ServerManager.restart already waits for (up to 120 s for a
             # 10 GB model cold-load). The previous code threw away that

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/tui/screens/setup.py

@@ -727,6 +727,28 @@ class SetupScreen(Screen):
             # the cohere binary on its own via cohere_server_path().
             save_config(config)
 
+        # muse_glimmer (Meta Muse Glimmer): the TurboQuant server lacks the
+        # arch, so build a dedicated stock llama-server from llama.cpp master
+        # (PR #26841) one-time before launching. Serves over the normal HTTP path.
+        if _arch_choice is not None and "muse" in str(
+            getattr(_arch_choice, "architecture", "")
+        ):
+            from ...bootstrap import ensure_muse_server
+
+            def _muse_progress(msg: str) -> None:
+                self._status_text = msg
+
+            ok, result = ensure_muse_server(on_progress=_muse_progress)
+            if not ok:
+                self.app.call_from_thread(lambda e=result: self._show_error(
+                    msg="Couldn't build the Muse Glimmer server.",
+                    code="E1002",
+                    details=e,
+                ))
+                return
+            config.runtime.muse_server_binary = result
+            save_config(config)
+
         # Launch server
         gw = LocalCodeRuntimeGateway(config.runtime)
         from ...bootstrap import _turboquant_binary_path as _tbp

{localcode-0.3.44 → localcode-0.3.46}/src/localcode/tui/widgets/chat_log.py

@@ -788,6 +788,12 @@ class ChatLog(RichLog):
             return
         self._think_stream_buf = ""
         self._think_stream_active = True
+        # Live-partial state: the trailing (not-yet-newline) line is rendered
+        # in place and rewritten as words arrive, so thinking flows word-by-word
+        # like the answer instead of snapping a whole line at a time.
+        self._think_partial_written = 0   # sublines the live partial occupies
+        self._think_partial_start = -1    # log index where the live partial begins
+        self._think_last_flush = 0.0      # monotonic ts of last partial flush
         self._dispatch_gap("thinking")
         self._history.append(("think_header",))
         self._render_think_header()
@@ -798,13 +804,70 @@ class ChatLog(RichLog):
         if not getattr(self, "_think_stream_active", False):
             self.start_thinking_stream()
         self._think_stream_buf += chunk
-        # Commit completed lines; keep the trailing partial buffered so we
-        # never render half a word mid-flight.
+        # Finalize every COMPLETE line (text before a newline): draw its final
+        # wrapped form, record it to history, and lock it in so the next partial
+        # starts fresh below it.
         while "\n" in self._think_stream_buf:
             line, self._think_stream_buf = self._think_stream_buf.split("\n", 1)
-            self._commit_thinking_line(line)
+            line = line.rstrip()
+            if line:
+                self._render_think_partial(line)
+                self._history.append(("think_line", line))
+            # Lock in whatever we just drew; the next partial is independent.
+            self._think_partial_written = 0
+            self._think_partial_start = -1
+        # Live-render the trailing partial word-by-word, rate-capped exactly like
+        # the content stream (word boundary + coalesce window). This is the fix
+        # for "jerky thinking": before, thinking only flushed on '\n', so at slow
+        # decode a whole line froze for ~2 s then snapped in.
+        tail = self._think_stream_buf
+        if not tail:
+            return
+        boundary = tail[-1] in self._STREAM_WORD_BOUNDARIES
+        now = time.monotonic()
+        if boundary and (now - self._think_last_flush) >= self._STREAM_COALESCE_SEC:
+            self._render_think_partial(tail)
+            self._think_last_flush = now
+
+    def _render_think_partial(self, text: str) -> None:
+        """Draw `text` as the current live thinking line, rewriting in place.
+
+        Mirrors the content stream's pop-and-rewrite (`_flush_stream`) but scoped
+        to ONE logical line (bounded cost) and guarded by an at-tail check so we
+        never pop lines another writer owns.
+        """
+        import textwrap
+        # Pop this partial's previous render — only if it's still the tail.
+        if self._think_partial_start >= 0 and self._think_partial_written > 0:
+            expected_tail = self._think_partial_start + self._think_partial_written
+            if expected_tail == len(self.lines):
+                for _ in range(self._think_partial_written):
+                    self.lines.pop()
+                self._line_counter = max(0, self._line_counter - self._think_partial_written)
+                self._line_cache.clear()
+            # else: lost the tail (a tool widget/rerender wrote after us) — leave
+            # the stale render; we restart the partial at the new bottom.
+        self._think_partial_start = len(self.lines)
+        self._think_partial_written = 0
+        try:
+            avail = self._content_width()
+        except Exception:
+            avail = 76
+        wrapped = textwrap.fill(
+            text, width=max(avail - 4, 30),
+            initial_indent="    ", subsequent_indent="    ",
+        )
+        follow = self.scroll_offset.y >= self.max_scroll_y - 2
+        for wline in wrapped.split("\n"):
+            self.write(Text(wline, style="dim italic"))
+            self._track_lines()
+            self._think_partial_written += 1
+        if follow:
+            self.scroll_end(animate=False)
 
     def _commit_thinking_line(self, line: str) -> None:
+        # Retained for `append_thinking` / non-streaming callers. The live
+        # streaming path uses `_render_think_partial` for word-by-word flow.
         line = line.rstrip()
         if not line:
             return
@@ -814,9 +877,13 @@ class ChatLog(RichLog):
     def end_thinking_stream(self) -> None:
         if not getattr(self, "_think_stream_active", False):
             return
-        if self._think_stream_buf.strip():
-            self._commit_thinking_line(self._think_stream_buf)
+        tail = self._think_stream_buf.strip()
+        if tail:
+            self._render_think_partial(tail)
+            self._history.append(("think_line", tail))
         self._think_stream_buf = ""
+        self._think_partial_written = 0
+        self._think_partial_start = -1
         self._think_stream_active = False
 
     def _render_think_header(self) -> None:

{localcode-0.3.44 → localcode-0.3.46/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.44
+Version: 0.3.46
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -135,13 +135,14 @@ On launch, LocalCode recommends the best model for **your Mac's RAM** — there'
 | Gemma 4 26B-A4B | 11.2 GB (Q3) | 3.8B (8/128 experts) | 24 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 10.7 GB (Q2) | 3.0B (8+1/256) | 24 GB | qwen35moe |
 | Qwen 3.8 27B | 17.9 GB (Q4) | 27B (dense) | 32 GB | qwen35 |
+| Muse Glimmer 30B † | 15.9 GB (Q4) | 30B (dense, multimodal) | 32 GB | muse_glimmer |
 | DiffusionGemma 26B-A4B † | 15.7 GB (Q4) | 4B (diffusion MoE) | 32 GB | diffusion_gemma |
 | North-Mini-Code 30B-A3B † | 17.9 GB (Q4) | 3B (30B MoE) | 36 GB | cohere2_moe |
 | Gemma 4 12B (full) | 23.8 GB (BF16) | 12B (dense) | 48 GB | gemma4-iswa |
 | Gemma 4 26B-A4B | 28 GB (Q8) | 3.8B (8/128 experts) | 64 GB | gemma4-iswa |
 | Qwen 3.6 35B-A3B | 38.5 GB (Q8) | 3.0B (8+1/256) | 96 GB | qwen35moe |
 
-*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended (DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack).
+*Min RAM* is the threshold for auto-recommendation (weights ≤ ~55% of unified memory, leaving room for KV cache + OS); you can still pick a heavier model manually. **†** experimental — pickable but **not** auto-recommended. DiffusionGemma needs a separate runner; `cohere2_moe` is unvalidated on this stack; Muse Glimmer's `muse_glimmer` arch isn't in the TurboQuant server, so LocalCode builds a dedicated stock llama-server (llama.cpp PR #26841) on first use and serves it without TurboQuant KV compression.
 
 ## How LocalCode works
 

{localcode-0.3.44 → localcode-0.3.46}/tests/test_comprehensive_models_matrix.py

@@ -45,6 +45,8 @@ def _backend_for(arch: str) -> str:
         return "diffusion_cli"
     if "cohere" in a:
         return "cohere_server"
+    if "muse" in a:
+        return "muse_server"
     return "turboquant_server"
 
 
@@ -67,10 +69,13 @@ def _make_gw(tmp_path: Path, choice, ram_gb: int) -> LocalCodeRuntimeGateway:
     turbo.write_text("#!/bin/sh\n")
     cohere = tmp_path / "llama-server-cohere"
     cohere.write_text("#!/bin/sh\n")
+    muse = tmp_path / "llama-server-muse"
+    muse.write_text("#!/bin/sh\n")
     diff = tmp_path / "llama-diffusion-cli"
     diff.write_text("#!/bin/sh\n")
     cfg.llama_cpp_binary = str(turbo)
     cfg.cohere_server_binary = str(cohere)
+    cfg.muse_server_binary = str(muse)
     cfg.diffusion_cli_binary = str(diff)
     gw = LocalCodeRuntimeGateway(cfg)
     return gw
@@ -92,6 +97,7 @@ def test_every_choice_is_wellformed(choice):
     assert choice.size_gb and choice.size_gb > 0
     assert choice.architecture in {
         "gemma4-iswa", "qwen35moe", "qwen35", "diffusion_gemma", "cohere2_moe",
+        "muse_glimmer",
     }, f"unknown arch {choice.architecture!r}"
     # by_filename must round-trip to a choice carrying the same architecture
     # (this is the dispatch key the runtime keys off).
@@ -136,9 +142,19 @@ def test_server_command_is_sane_for_every_ram(tmp_path, choice, ram_gb):
         for i, tok in enumerate(cmd):
             if tok in ("--cache-type-v", "--cache-type-k"):
                 assert cmd[i + 1] not in _TURBO_CACHE_VALUES, "cohere = stock KV only"
+    elif backend == "muse_server":
+        assert cmd[0].endswith("llama-server-muse")
+        assert "--jinja" in cmd, "Muse Glimmer requires --jinja (its chat template)"
+        # Stock binary: none of the TurboQuant-only flags / KV values.
+        for flag in _TURBO_ONLY:
+            assert flag not in cmd, f"muse server must not get {flag}"
+        for i, tok in enumerate(cmd):
+            if tok in ("--cache-type-v", "--cache-type-k"):
+                assert cmd[i + 1] not in _TURBO_CACHE_VALUES, "muse = stock KV only"
     else:
         assert cmd[0].endswith("llama-server")
         assert not cmd[0].endswith("llama-server-cohere")
+        assert not cmd[0].endswith("llama-server-muse")
 
     # Common required flags.
     assert "--model" in cmd and "--port" in cmd

{localcode-0.3.44 → localcode-0.3.46}/tests/test_models_catalog.py

@@ -79,6 +79,7 @@ _EXPECTED_VISION = {
     "gemma-q8": True,
     "qwen-q8": True,
     "qwen38": True,
+    "muse-glimmer": True,
     "diffusiongemma": False,
     "north-mini-code": False,
 }

{localcode-0.3.44 → localcode-0.3.46}/tests/test_quant_browser_and_thinking.py

@@ -59,19 +59,30 @@ def test_no_catalog_gemma_duplicates():
 # ── Live reasoning stream: buffer partials, flush whole lines ───────────
 
 class _FakeLog:
-    """Minimal stand-in exercising ChatLog's thinking-stream methods."""
+    """Stand-in exercising ChatLog's thinking-stream methods, including the
+    in-place partial rewrite (pop + re-render) the word-by-word path uses.
+    `lines` emulates RichLog.lines (pop-able); `written` is the cumulative
+    record of everything ever rendered."""
     def __init__(self):
+        import types as _t
         self.written = []
+        self.lines = []
         self._history = []
         self._think_stream_active = False
         self._think_stream_buf = ""
+        self._line_counter = 0
+        self._line_cache = {}
+        self.scroll_offset = _t.SimpleNamespace(y=0)
+        self.max_scroll_y = 0
 
     # Methods copied-by-reference from ChatLog via bind below.
     def write(self, renderable):
-        self.written.append(str(getattr(renderable, "plain", renderable)))
+        s = str(getattr(renderable, "plain", renderable))
+        self.written.append(s)
+        self.lines.append(s)
 
     def _track_lines(self):
-        pass
+        self._line_counter += 1
 
     def _dispatch_gap(self, _kind):
         pass
@@ -79,35 +90,49 @@ class _FakeLog:
     def _content_width(self):
         return 80
 
+    def scroll_end(self, **kwargs):
+        pass
+
 
 def _bind_stream_methods(obj):
     from localcode.tui.widgets.chat_log import ChatLog
     import types
     for name in ("start_thinking_stream", "stream_thinking",
                  "_commit_thinking_line", "_render_think_header",
-                 "_render_think_line", "end_thinking_stream"):
+                 "_render_think_line", "_render_think_partial",
+                 "end_thinking_stream"):
         setattr(obj, name, types.MethodType(getattr(ChatLog, name), obj))
+    # Stream-pacing constants are ChatLog class attrs; the fake isn't a
+    # subclass, so copy them over (kept in sync with the real values).
+    for const in ("_STREAM_WORD_BOUNDARIES", "_STREAM_COALESCE_SEC"):
+        setattr(obj, const, getattr(ChatLog, const))
 
 
-def test_thinking_stream_flushes_whole_lines_only():
+def test_thinking_stream_commits_lines_and_streams_partial_words():
     log = _FakeLog()
     _bind_stream_methods(log)
-    log.stream_thinking("First reasoning line\nSecond li")
-    # Header + first complete line written; partial "Second li" still buffered.
+    # A complete line, then a partial that ENDS on a word boundary (space) —
+    # the fix streams that partial live instead of freezing until the newline.
+    log.stream_thinking("First reasoning line\nSecond word ")
     joined = " ".join(log.written)
     assert "thinking" in joined.lower()
     assert "First reasoning line" in joined
-    assert "Second li" not in joined
-    assert log._think_stream_buf == "Second li"
+    # NEW behavior: the trailing partial renders word-by-word before any newline.
+    assert "Second word" in joined
+    assert log._think_stream_buf == "Second word "
+    # The completed line is locked into history; the live partial is not (yet).
+    assert ("think_line", "First reasoning line") in log._history
 
 
 def test_thinking_stream_end_flushes_partial():
     log = _FakeLog()
     _bind_stream_methods(log)
+    # Ends on 'e' (no word boundary) → stays buffered, not yet rendered.
     log.stream_thinking("partial tail with no newline")
     assert "partial tail" not in " ".join(log.written)  # buffered, not flushed
     log.end_thinking_stream()
     assert "partial tail with no newline" in " ".join(log.written)
+    assert ("think_line", "partial tail with no newline") in log._history
     assert log._think_stream_active is False