localcode 0.5.18__tar.gz → 0.5.20__tar.gz

{localcode-0.5.18/src/localcode.egg-info → localcode-0.5.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.18
+Version: 0.5.20
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -136,13 +136,16 @@ localcode recommends a model by your Mac's memory and marks it with a star. You
 | Muse Glimmer 30B | 15.9 GB | UD-Q4_K_XL | 30B (dense, vision) | 32 GB |
 | Qwen 3.8 27B | 17.9 GB | UD-Q4_K_XL | 27B (dense) | 36 GB |
 | North-Mini-Code 30B-A3B | 17.9 GB | UD-Q4_K_M | 3B (MoE) | 36 GB |
+| OpenJev 27B (decision model) | 19.0 GB | Q4_K_M | 27B (dense) | 36 GB |
 | Gemma 4 12B (full) | 23.8 GB | BF16 | 12B (dense) | 48 GB |
 | Gemma 4 26B-A4B | 28.0 GB | UD-Q8_K_XL | 3.8B (MoE) | 64 GB |
+| Qwen 3.8 27B | 31.5 GB | UD-Q8_K_XL | 27B (dense) | 64 GB |
 | Qwen 3.6 35B-A3B | 38.5 GB | UD-Q8_K_XL | 3.0B (MoE) | 96 GB |
+| Kolibri 1 78B-A3B (experimental) | 47.5 GB | Q4_K_M | 3.5B (MoE) | 96 GB |
 
 [Underdog Saluki 27B 1.0](https://huggingface.co/ConwayResearch/Underdog-Saluki-27B-1.0) is also available as an opt-in IQ2-mix model: 7.9 GB of weights, plus memory for context and runtime, with an optional 0.93 GB vision projector. Coding quality and minimum RAM have not been benchmarked on LocalCode.
 
-Min RAM is the memory at which localcode will recommend the model. You can pick a heavier one by hand. DiffusionGemma is a research model that is never recommended automatically.
+Min RAM is the smallest Mac whose memory the weights fit in (about 55% of unified memory). You can pick a heavier one by hand. DiffusionGemma, Kolibri, OpenJev and Saluki are never recommended automatically: you choose them yourself.
 
 Measured on a top-memory Apple Silicon laptop with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
 

{localcode-0.5.18 → localcode-0.5.20}/README.md

@@ -88,13 +88,16 @@ localcode recommends a model by your Mac's memory and marks it with a star. You
 | Muse Glimmer 30B | 15.9 GB | UD-Q4_K_XL | 30B (dense, vision) | 32 GB |
 | Qwen 3.8 27B | 17.9 GB | UD-Q4_K_XL | 27B (dense) | 36 GB |
 | North-Mini-Code 30B-A3B | 17.9 GB | UD-Q4_K_M | 3B (MoE) | 36 GB |
+| OpenJev 27B (decision model) | 19.0 GB | Q4_K_M | 27B (dense) | 36 GB |
 | Gemma 4 12B (full) | 23.8 GB | BF16 | 12B (dense) | 48 GB |
 | Gemma 4 26B-A4B | 28.0 GB | UD-Q8_K_XL | 3.8B (MoE) | 64 GB |
+| Qwen 3.8 27B | 31.5 GB | UD-Q8_K_XL | 27B (dense) | 64 GB |
 | Qwen 3.6 35B-A3B | 38.5 GB | UD-Q8_K_XL | 3.0B (MoE) | 96 GB |
+| Kolibri 1 78B-A3B (experimental) | 47.5 GB | Q4_K_M | 3.5B (MoE) | 96 GB |
 
 [Underdog Saluki 27B 1.0](https://huggingface.co/ConwayResearch/Underdog-Saluki-27B-1.0) is also available as an opt-in IQ2-mix model: 7.9 GB of weights, plus memory for context and runtime, with an optional 0.93 GB vision projector. Coding quality and minimum RAM have not been benchmarked on LocalCode.
 
-Min RAM is the memory at which localcode will recommend the model. You can pick a heavier one by hand. DiffusionGemma is a research model that is never recommended automatically.
+Min RAM is the smallest Mac whose memory the weights fit in (about 55% of unified memory). You can pick a heavier one by hand. DiffusionGemma, Kolibri, OpenJev and Saluki are never recommended automatically: you choose them yourself.
 
 Measured on a top-memory Apple Silicon laptop with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
 

{localcode-0.5.18 → localcode-0.5.20}/pyproject.toml

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

{localcode-0.5.18 → localcode-0.5.20}/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.5.18"
+    __version__ = "0.5.20"

localcode-0.5.20/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.5.20/src/localcode/bin/localcode-ui
+size: 102460976 bytes
+sha256: 1d9a04fe1c30fea23a7b1beb7826e35a76fcca7ad82f4fffc9ae400104fad77b

localcode-0.5.20/src/localcode/ui/FORK_COMMIT

@@ -0,0 +1 @@
+e31e26f33142baab256b305e15cf2f1d0326590d

{localcode-0.5.18 → localcode-0.5.20}/src/localcode/ui/plugin/modes.ts

@@ -242,9 +242,9 @@ async function tui(api: TuiPluginApi) {
     } catch (e) { error(String(e)); }
   }
   api.keymap.registerLayer({ commands: [
-    { name: "localcode.server", title: "Model server connection and port", category: "LocalCode", slashName: "server", run: server },
-    { name: "localcode.mode", title: "Choose Chat or Decisions", category: "LocalCode", slashName: "mode", run: choose },
-    { name: "localcode.decide", title: "Open decision mode", category: "LocalCode", slashName: "decide", run: open },
+    { name: "localcode.server", title: "Model server connection and port", namespace: "palette", category: "LocalCode", slashName: "server", run: server },
+    { name: "localcode.mode", title: "Choose Chat or Decisions", namespace: "palette", category: "LocalCode", slashName: "mode", run: choose },
+    { name: "localcode.decide", title: "Open decision mode", namespace: "palette", category: "LocalCode", slashName: "decide", run: open },
   ] });
   api.keymap.registerLayer({ enabled: () => api.route.current.name === route && !api.ui.dialog.open, priority: 5, commands: [{ name: "localcode.mode.back", run: back }], bindings: [{ key: "escape", command: "localcode.mode.back" }] });
   const timer = setInterval(() => void poll(), 2000);

{localcode-0.5.18 → localcode-0.5.20}/src/localcode/ui/supervisor.py

@@ -16,8 +16,9 @@ through bootstrap.download_model — the same code the Textual picker uses.
     GET  /models_dir         {"path", "free_gb"}
     GET  /progress           prompt-fill progress of the running request (from llama-server /slots)
     GET  /voice/status       {"ready", "recording", "detail"}   (whisper env + STT model)
-    POST /voice/start        start recording the default mic (PortAudio, 16 kHz mono wav)
-    POST /voice/stop         stop, transcribe locally (whisper.cpp), {"text"}
+    POST /voice/start        open the default mic (PortAudio, 16 kHz mono) and start live dictation
+    GET  /voice/partial      {"text", "recording"}: what has been heard so far, while recording
+    POST /voice/stop         stop, {"text"}: the final transcript (whisper.cpp, local)
     POST /voice/speak {"text"}   read text aloud with macOS `say`
     POST /models_dir {"path"}   change where GGUFs download to (persisted in localcode's config)
 
@@ -670,6 +671,10 @@ class Supervisor:
     voice_wav = HERE / "voice.wav"
     voice_detail = ""
     voice_setup_lock = threading.Lock()
+    voice_live = False          # the running recorder is the live-dictation worker
+    voice_partial_text = ""     # what it has heard so far
+    voice_final: dict | None = None
+    voice_final_ready = threading.Event()
 
     @staticmethod
     def _voice_venv() -> Path:
@@ -737,10 +742,7 @@ class Supervisor:
 
     @staticmethod
     def _mic_device() -> str:
-        """ffmpeg avfoundation audio device index: LOCALCODE_MIC, else the built-in mic, else 0."""
-        env = os.environ.get("LOCALCODE_MIC")
-        if env:
-            return env
+        """ffmpeg avfoundation audio device index: the built-in mic, else 0."""
         try:
             out = subprocess.run(["ffmpeg", "-hide_banner", "-f", "avfoundation", "-list_devices", "true", "-i", ""],
                                  capture_output=True, text=True, timeout=15, check=False).stderr
@@ -752,21 +754,6 @@ class Supervisor:
             pass
         return "0"
 
-    # Recorder that runs inside the voice venv: PortAudio ships in the sounddevice
-    # wheel, so no ffmpeg/Homebrew is needed. Records 16 kHz mono until stdin closes.
-    _RECORDER = """
-import sys, wave, sounddevice as sd
-path = sys.argv[1]
-frames = []
-def cb(indata, n, t, status):
-    frames.append(bytes(indata))
-with sd.RawInputStream(samplerate=16000, channels=1, dtype='int16', callback=cb):
-    sys.stdout.write('recording\\n'); sys.stdout.flush()
-    sys.stdin.read()
-with wave.open(path, 'wb') as w:
-    w.setnchannels(1); w.setsampwidth(2); w.setframerate(16000); w.writeframes(b''.join(frames))
-"""
-
     def voice_start(self) -> dict:
         if self.voice_proc is not None and self.voice_proc.poll() is None:
             return {"error": "already recording"}
@@ -776,8 +763,7 @@ with wave.open(path, 'wb') as w:
         self.voice_wav.unlink(missing_ok=True)
         try:
             subprocess.run([str(py), "-c", "import sounddevice"], check=True, capture_output=True, timeout=30)
-            cmd = [str(py), "-c", self._RECORDER, str(self.voice_wav)]
-            self.voice_recorder = "portaudio"
+            return self._voice_start_live(py)
         except Exception:  # noqa: BLE001
             if not shutil.which("ffmpeg"):
                 return {"error": "no recorder available: run /voice setup again (installs the PortAudio recorder) or brew install ffmpeg"}
@@ -792,8 +778,69 @@ with wave.open(path, 'wb') as w:
             return {"error": f"could not open the microphone: {err or 'unknown error'} (grant microphone access to your terminal in System Settings → Privacy)"}
         return {"ok": True}
 
+    def _voice_start_live(self, py: Path) -> dict:
+        """Live dictation (localcode/voice_live.py): one worker records and
+        transcribes as you speak, and yields the GPU to the coding model."""
+        from localcode.voice import DEFAULT_STT_MODEL_DIR, DEFAULT_STT_MODEL_NAME, VoiceState
+        model = VoiceState().stt_model_path or (DEFAULT_STT_MODEL_DIR / DEFAULT_STT_MODEL_NAME)
+        worker = Path(localcode.__file__).resolve().parent / "voice_live.py"
+        env = {**os.environ, "LOCALCODE_CONTROL_URL": f"http://127.0.0.1:{self.control_port}", "LOCALCODE_CONTROL_TOKEN": self.control_token}
+        self.voice_recorder, self.voice_live, self.voice_partial_text, self.voice_final = "portaudio", True, "", None
+        self.voice_final_ready = threading.Event()
+        opened, done = threading.Event(), self.voice_final_ready
+        proc = subprocess.Popen([str(py), str(worker), str(model)], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, env=env, text=True)
+        self.voice_proc = proc
+
+        def read() -> None:
+            final: dict = {"error": "the voice worker stopped without a transcript"}
+            for line in proc.stdout:  # type: ignore[union-attr]
+                try:
+                    msg = json.loads(line)
+                except ValueError:
+                    continue
+                kind = msg.get("type")
+                if kind == "recording":
+                    opened.set()
+                elif kind == "partial" and self.voice_proc is proc:
+                    self.voice_partial_text = str(msg.get("text", ""))
+                elif kind == "final":
+                    final = {"ok": True, "text": str(msg.get("text", ""))}
+                elif kind == "error":
+                    final = {"error": str(msg.get("message", "voice worker failed"))}
+            if self.voice_proc is proc or self.voice_final is None:
+                self.voice_final = final
+            opened.set(); done.set()
+
+        threading.Thread(target=read, daemon=True).start()
+        opened.wait(timeout=8)
+        if proc.poll() is not None:
+            self.voice_proc, self.voice_live = None, False
+            err = (self.voice_final or {}).get("error") or "unknown error"
+            return {"error": f"could not open the microphone: {err} (grant microphone access to your terminal in System Settings → Privacy)"}
+        return {"ok": True, "live": True}
+
+    def voice_partial(self) -> dict:
+        recording = self.voice_proc is not None and self.voice_proc.poll() is None
+        return {"recording": recording, "live": self.voice_live, "text": self.voice_partial_text if self.voice_live else ""}
+
+    def _voice_stop_live(self, p: subprocess.Popen) -> dict:
+        done = self.voice_final_ready
+        try:
+            p.stdin.close()  # type: ignore[union-attr]
+        except Exception:  # noqa: BLE001
+            p.terminate()
+        if not done.wait(timeout=120):
+            p.kill()
+        self.voice_proc, self.voice_live = None, False
+        out = self.voice_final or {"error": "transcription timed out"}
+        if "error" in out:
+            return {"error": f"transcription failed: {out['error']}"}
+        return {"ok": True, "text": out.get("text", "").strip()}
+
     def voice_stop(self) -> dict:
         p = self.voice_proc
+        if p is not None and self.voice_live:
+            return self._voice_stop_live(p)      # also when the worker already ended: its transcript is kept
         if p is None or p.poll() is not None:
             return {"error": "not recording"}
         try:
@@ -958,6 +1005,8 @@ def make_handler(sup: Supervisor):
                 return self._json(sup.models_dir_info())
             if u.path == "/voice/status":
                 return self._json(sup.voice_status())
+            if u.path == "/voice/partial":
+                return self._json(sup.voice_partial())
             if u.path == "/progress":
                 return self._json(sup.progress())
             self._json({"error": "not found"}, 404)

localcode-0.5.20/src/localcode/voice_live.py

@@ -0,0 +1,214 @@
+"""Live dictation: the worker the supervisor runs while the microphone is open.
+
+It records, and while you speak it transcribes the part you have not finished
+yet about once a second, so the words appear as you say them. whisper.cpp is not
+a streaming model, so "live" is done by window: speech that is followed by a
+pause is transcribed once and committed, and only the open tail after it is
+transcribed again on each tick.
+
+It shares the GPU with the coding model, and yields to it:
+  * the speech model is loaded once, not on every use;
+  * nothing is transcribed while the coding model is reading or generating, so
+    dictating over a running answer costs it nothing (the text arrives when it
+    finishes, or when you stop);
+  * each tick waits three times as long as the last one took (up to 2.5 s),
+    so dictation normally uses a quarter of the GPU at most;
+  * silence is never transcribed.
+
+Protocol, one JSON object per line on stdout:
+  {"type": "recording"}                    the microphone is open
+  {"type": "partial", "text": "..."}       everything heard so far
+  {"type": "final", "text": "..."}         after stdin closes
+  {"type": "error", "message": "..."}
+
+Run inside the voice runtime:  python voice_live.py <speech model> [--wav FILE]
+`--wav` replays a 16 kHz mono file at real-time pace instead of opening the
+microphone; the tests use it.
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import threading
+import time
+import urllib.request
+import wave
+
+RATE = 16000
+TICK_SECONDS = 0.9            # how often the open tail is re-transcribed, at best
+YIELD_FACTOR = 3.0            # wait this many times the last transcription before the next
+MAX_WAIT_SECONDS = 2.5        # but never leave the words more than this far behind
+MIN_SPEECH_SECONDS = 1.0      # do not transcribe less than this: a clip that short is mostly guessed
+PAUSE_SECONDS = 0.7           # a pause this long ends a phrase
+MAX_TAIL_SECONDS = 12.0       # an unbroken tail longer than this is cut at its quietest point
+FRAME = RATE // 50            # 20 ms
+SILENCE_RMS = 350.0           # int16; room noise sits well under this
+
+
+def emit(obj: dict) -> None:
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def frame_rms(samples):
+    """RMS of each 20 ms frame of an int16 array."""
+    import numpy as np
+    n = len(samples) // FRAME
+    if n == 0:
+        return np.zeros(0)
+    frames = samples[: n * FRAME].astype("float32").reshape(n, FRAME)
+    return np.sqrt((frames * frames).mean(axis=1))
+
+
+def trailing_silence(samples) -> float:
+    """Seconds of silence at the end."""
+    rms = frame_rms(samples)
+    quiet = 0
+    for value in rms[::-1]:
+        if value >= SILENCE_RMS:
+            break
+        quiet += 1
+    return quiet * FRAME / RATE
+
+
+def has_speech(samples) -> bool:
+    rms = frame_rms(samples)
+    return bool(len(rms)) and int((rms >= SILENCE_RMS).sum()) * FRAME / RATE >= 0.2
+
+
+def quietest_cut(samples) -> int:
+    """Where to cut an over-long tail: the quietest 200 ms in its last four
+    seconds, leaving at least half a second after it."""
+    import numpy as np
+    rms = frame_rms(samples)
+    lo, hi = max(0, len(rms) - 200), len(rms) - 25
+    if hi - lo < 10:
+        return len(samples)
+    window = np.convolve(rms[lo:hi], np.ones(10) / 10, mode="valid")
+    return (lo + int(window.argmin()) + 5) * FRAME
+
+
+def join(committed: str, tail: str) -> str:
+    return " ".join(part for part in (committed.strip(), tail.strip()) if part)
+
+
+class CodingModel:
+    """Whether the coding model is using the GPU right now, from the
+    supervisor's own progress report. Unknown counts as idle."""
+
+    def __init__(self) -> None:
+        self.url = os.environ.get("LOCALCODE_CONTROL_URL", "").rstrip("/")
+        self.token = os.environ.get("LOCALCODE_CONTROL_TOKEN", "")
+
+    def busy(self) -> bool:
+        if not self.url:
+            return False
+        try:
+            req = urllib.request.Request(self.url + "/progress", headers={"X-Localcode-Token": self.token})
+            with urllib.request.urlopen(req, timeout=0.4) as r:
+                return json.load(r).get("phase") in ("reading", "generating")
+        except Exception:  # noqa: BLE001
+            return False
+
+
+class Audio:
+    """Everything captured so far, as int16 chunks."""
+
+    def __init__(self) -> None:
+        self.lock = threading.Lock()
+        self.chunks: list[bytes] = []
+        self.done = threading.Event()
+
+    def add(self, data: bytes) -> None:
+        with self.lock:
+            self.chunks.append(data)
+
+    def samples(self):
+        import numpy as np
+        with self.lock:
+            data = b"".join(self.chunks)
+        return np.frombuffer(data, dtype="int16")
+
+
+def replay(audio: Audio, path: str, stop: threading.Event) -> None:
+    """Feed a wav file at the pace a microphone would."""
+    with wave.open(path, "rb") as w:
+        if w.getframerate() != RATE or w.getnchannels() != 1 or w.getsampwidth() != 2:
+            raise ValueError("--wav needs 16 kHz mono 16-bit audio")
+        step = RATE // 10
+        while not stop.is_set():
+            data = w.readframes(step)
+            if not data:
+                break
+            audio.add(data)
+            time.sleep(0.1)
+    audio.done.set()
+
+
+def main() -> int:
+    model_path = sys.argv[1]
+    wav = sys.argv[sys.argv.index("--wav") + 1] if "--wav" in sys.argv else os.environ.get("LOCALCODE_VOICE_TEST_WAV")
+    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from localcode.voice import _clean_transcript, _silence_native_stderr
+
+    audio, stop = Audio(), threading.Event()
+    threading.Thread(target=lambda: (sys.stdin.read(), stop.set()), daemon=True).start()
+
+    stream = None
+    if wav:
+        threading.Thread(target=replay, args=(audio, wav, stop), daemon=True).start()
+    else:
+        import sounddevice as sd
+        stream = sd.RawInputStream(samplerate=RATE, channels=1, dtype="int16", callback=lambda data, n, t, status: audio.add(bytes(data)))
+        stream.start()
+    emit({"type": "recording"})
+
+    from pywhispercpp.model import Model
+    with _silence_native_stderr():
+        model = Model(model_path, n_threads=4, print_realtime=False, print_progress=False, print_timestamps=False)
+
+    def transcribe(samples) -> str:
+        with _silence_native_stderr():
+            segments = model.transcribe(samples.astype("float32") / 32768.0)
+        return _clean_transcript(" ".join(s.text for s in segments).strip())
+
+    coding_model = CodingModel()
+    committed, start, last_partial, took = "", 0, "", 0.0
+    while not stop.is_set() and not audio.done.is_set():
+        stop.wait(max(TICK_SECONDS, min(took * YIELD_FACTOR, MAX_WAIT_SECONDS)))
+        if stop.is_set():
+            break
+        tail = audio.samples()[start:]
+        if len(tail) < MIN_SPEECH_SECONDS * RATE or coding_model.busy():
+            continue
+        if not has_speech(tail):
+            start += max(0, len(tail) - RATE // 2)          # nothing said: drop the silence, keep half a second of lead-in
+            continue
+        paused = trailing_silence(tail) >= PAUSE_SECONDS
+        too_long = len(tail) > MAX_TAIL_SECONDS * RATE
+        cut = len(tail) if paused or not too_long else quietest_cut(tail)
+        began = time.monotonic()
+        text = transcribe(tail[:cut])
+        took = time.monotonic() - began
+        if paused or too_long:
+            committed, start, text = join(committed, text), start + cut, ""
+        partial = join(committed, text)
+        if partial != last_partial:
+            last_partial = partial
+            emit({"type": "partial", "text": partial})
+
+    if stream is not None:
+        stream.stop(); stream.close()
+    tail = audio.samples()[start:]
+    text = transcribe(tail) if len(tail) >= RATE // 5 and has_speech(tail) else ""
+    emit({"type": "final", "text": join(committed, text)})
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        raise SystemExit(main())
+    except Exception as e:  # noqa: BLE001 - the supervisor shows this to the user
+        emit({"type": "error", "message": f"{type(e).__name__}: {e}"})
+        raise SystemExit(1)

{localcode-0.5.18 → localcode-0.5.20/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.18
+Version: 0.5.20
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -136,13 +136,16 @@ localcode recommends a model by your Mac's memory and marks it with a star. You
 | Muse Glimmer 30B | 15.9 GB | UD-Q4_K_XL | 30B (dense, vision) | 32 GB |
 | Qwen 3.8 27B | 17.9 GB | UD-Q4_K_XL | 27B (dense) | 36 GB |
 | North-Mini-Code 30B-A3B | 17.9 GB | UD-Q4_K_M | 3B (MoE) | 36 GB |
+| OpenJev 27B (decision model) | 19.0 GB | Q4_K_M | 27B (dense) | 36 GB |
 | Gemma 4 12B (full) | 23.8 GB | BF16 | 12B (dense) | 48 GB |
 | Gemma 4 26B-A4B | 28.0 GB | UD-Q8_K_XL | 3.8B (MoE) | 64 GB |
+| Qwen 3.8 27B | 31.5 GB | UD-Q8_K_XL | 27B (dense) | 64 GB |
 | Qwen 3.6 35B-A3B | 38.5 GB | UD-Q8_K_XL | 3.0B (MoE) | 96 GB |
+| Kolibri 1 78B-A3B (experimental) | 47.5 GB | Q4_K_M | 3.5B (MoE) | 96 GB |
 
 [Underdog Saluki 27B 1.0](https://huggingface.co/ConwayResearch/Underdog-Saluki-27B-1.0) is also available as an opt-in IQ2-mix model: 7.9 GB of weights, plus memory for context and runtime, with an optional 0.93 GB vision projector. Coding quality and minimum RAM have not been benchmarked on LocalCode.
 
-Min RAM is the memory at which localcode will recommend the model. You can pick a heavier one by hand. DiffusionGemma is a research model that is never recommended automatically.
+Min RAM is the smallest Mac whose memory the weights fit in (about 55% of unified memory). You can pick a heavier one by hand. DiffusionGemma, Kolibri, OpenJev and Saluki are never recommended automatically: you choose them yourself.
 
 Measured on a top-memory Apple Silicon laptop with Qwen 3.6 35B-A3B UD-IQ2_M at a 131072-token context: about 89 tokens/s generation, about 1174 tokens/s prompt processing, and 12 to 15 seconds for a typical four-tool-call task.
 

{localcode-0.5.18 → localcode-0.5.20}/src/localcode.egg-info/SOURCES.txt

@@ -1187,6 +1187,7 @@ src/localcode/thermal.py
 src/localcode/thinking.py
 src/localcode/transfer.py
 src/localcode/voice.py
+src/localcode/voice_live.py
 src/localcode.egg-info/PKG-INFO
 src/localcode.egg-info/SOURCES.txt
 src/localcode.egg-info/dependency_links.txt
@@ -1266,4 +1267,5 @@ tests/test_ui_gateway_live.py
 tests/test_ui_launch.py
 tests/test_ui_server.py
 tests/test_ui_server_lifecycle.py
-tests/test_ui_warmup.py
+tests/test_ui_warmup.py
+tests/test_voice_live.py

{localcode-0.5.18 → localcode-0.5.20}/tests/test_ui_launch.py

@@ -294,3 +294,4 @@ def test_entrypoint_routes_mcp(monkeypatch):
     with pytest.raises(SystemExit) as e:
         entrypoint.main(["mcp", "list"])
     assert e.value.code == 0 and seen["argv"] == ["list"]
+

localcode-0.5.20/tests/test_voice_live.py

@@ -0,0 +1,103 @@
+"""Live dictation: the pacing rules, and the worker against a spoken clip.
+
+The clip tests need the voice runtime and speech model that `/voice` installs;
+without them they are skipped. Nothing is downloaded.
+"""
+import json
+import os
+import subprocess
+import sys
+import threading
+import wave
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+WORKER = ROOT / "src/localcode/voice_live.py"
+VOICE_PY = Path.home() / ".local/share/localcode-agent/run/voice-venv/bin/python"
+MODEL = Path.home() / ".local/share/localcode/voice/ggml-medium.en-q5_0.bin"
+
+
+def test_pacing_helpers():
+    np = pytest.importorskip("numpy")
+    sys.path.insert(0, str(ROOT / "src"))
+    from localcode import voice_live as v
+
+    rate = v.RATE
+    t = np.arange(rate) / rate
+    speech = (np.sin(2 * np.pi * 220 * t) * 6000).astype("int16")          # one loud second
+    silence = np.zeros(rate, dtype="int16")
+    assert v.has_speech(speech) and not v.has_speech(silence)
+    assert v.trailing_silence(np.concatenate([speech, silence])) == pytest.approx(1.0, abs=0.05)
+    assert v.trailing_silence(speech) == 0
+    # an over-long tail is cut inside its quiet gap, not in the middle of a word
+    tail = np.concatenate([speech] * 9 + [silence[: rate // 2]] + [speech] * 3)
+    cut = v.quietest_cut(tail)
+    assert 9 * rate <= cut <= 9.5 * rate
+    assert v.join("one two", " three ") == "one two three" and v.join("", "x") == "x" and v.join("x", "") == "x"
+
+
+def _clip(tmp_path) -> Path:
+    if sys.platform != "darwin" or not VOICE_PY.exists() or not MODEL.exists():
+        pytest.skip("needs the voice runtime and speech model installed by /voice")
+    aiff, wav = tmp_path / "clip.aiff", tmp_path / "clip.wav"
+    subprocess.run(["say", "-o", str(aiff), "Open the file called calculator. [[slnc 1000]] Then run the test suite."], check=True)
+    subprocess.run(["afconvert", "-f", "WAVE", "-d", "LEI16@16000", "-c", "1", str(aiff), str(wav)], check=True)
+    with wave.open(str(wav)) as w:
+        assert w.getframerate() == 16000
+    return wav
+
+
+def _run(wav: Path, env: dict) -> list[dict]:
+    r = subprocess.run([str(VOICE_PY), str(WORKER), str(MODEL), "--wav", str(wav)], input="", capture_output=True, text=True, timeout=180,
+                       env={**os.environ, **env})
+    return [json.loads(line) for line in r.stdout.splitlines() if line.startswith("{")]
+
+
+def test_words_arrive_while_speaking_and_the_final_text_is_whole(tmp_path):
+    wav = _clip(tmp_path)
+    # stdin is closed at once, which is "stop": the worker must still finish the audio it holds
+    lines = _run(wav, {"LOCALCODE_CONTROL_URL": ""})
+    assert lines[0] == {"type": "recording"} and lines[-1]["type"] == "final"
+
+    proc = subprocess.Popen([str(VOICE_PY), str(WORKER), str(MODEL), "--wav", str(wav)], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                            stderr=subprocess.DEVNULL, text=True, env={**os.environ, "LOCALCODE_CONTROL_URL": ""})
+    seen = [json.loads(line) for line in proc.stdout if line.startswith("{")]        # the clip ends by itself
+    proc.wait(timeout=60)
+    partials = [m["text"] for m in seen if m["type"] == "partial"]
+    final = seen[-1]["text"].lower()
+    # how many partials arrive depends on how busy the GPU is; one is enough to show the text came early
+    assert partials, "text must arrive before the end"
+    assert any("calculator" in p.lower() for p in partials)
+    assert "calculator" in final and "test suite" in final
+
+
+def test_nothing_is_transcribed_while_the_coding_model_is_busy(tmp_path):
+    wav = _clip(tmp_path)
+
+    class Busy(BaseHTTPRequestHandler):
+        asked = 0
+
+        def do_GET(self):
+            Busy.asked += 1
+            body = json.dumps({"phase": "generating"}).encode()
+            self.send_response(200); self.send_header("Content-Length", str(len(body))); self.end_headers(); self.wfile.write(body)
+
+        def log_message(self, *a):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Busy)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    try:
+        proc = subprocess.Popen([str(VOICE_PY), str(WORKER), str(MODEL), "--wav", str(wav)], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                                stderr=subprocess.DEVNULL, text=True,
+                                env={**os.environ, "LOCALCODE_CONTROL_URL": f"http://127.0.0.1:{server.server_port}", "LOCALCODE_CONTROL_TOKEN": "t"})
+        seen = [json.loads(line) for line in proc.stdout if line.startswith("{")]
+        proc.wait(timeout=60)
+    finally:
+        server.shutdown()
+    assert Busy.asked >= 2
+    assert [m for m in seen if m["type"] == "partial"] == []          # the GPU was left to the coding model
+    assert "calculator" in seen[-1]["text"].lower()                    # and nothing was lost: it is all in the final text

localcode-0.5.18/src/localcode/bin/localcode-ui

@@ -1,4 +0,0 @@
-[diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.18/src/localcode/bin/localcode-ui
-size: 102460976 bytes
-sha256: 04037d39bcaa5b66e084ab6ad392f9246d8692aca1ea0d8177805a725ddebb4c

localcode-0.5.18/src/localcode/ui/FORK_COMMIT

@@ -1 +0,0 @@
-214326b4b0965af136f80684dc18431f25adeb4a