localcode 0.5.2__tar.gz → 0.5.4__tar.gz

{localcode-0.5.2/src/localcode.egg-info → localcode-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.2
+Version: 0.5.4
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -39,14 +39,15 @@ Requires-Dist: pywhispercpp>=1.2.0; extra == "voice"
 Requires-Dist: sounddevice>=0.4.6; extra == "voice"
 Requires-Dist: numpy>=1.26.0; extra == "voice"
 Requires-Dist: piper-tts>=1.2.0; extra == "voice"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-timeout; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
 Dynamic: license-file
 
 <p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-dark-v2.png">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-light-v2.png">
-    <img alt="localcode" src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-light-v2.png" width="360">
-  </picture>
+  <img alt="localcode" src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-dark.svg" width="360">
 </p>
 
 <p align="center">
@@ -57,8 +58,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <strong>A coding agent that runs a local model on your Mac.</strong><br>
-  No cloud inference, no API key, no account.
+  <strong>Agentic coding. Local models. On your Mac.</strong>
 </p>
 
 <p align="center">
@@ -87,6 +87,11 @@ repository ships, with the size and whether it fits your Mac's memory. The
 recommended one for your machine is starred. Pick one, watch the download, and
 start typing. `/models` switches later.
 
+OpenJev also supports typed decisions: use `/mode` to choose **Chat** or
+**Decisions**, or run `localcode --mode decisions`. The decision screen returns
+choices, yes/no probabilities and scores without running coding tools.
+See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
+
 ```
 > Implement the retry decorator in retry.py so every test in test_retry.py passes. Then run: pytest -q
 ```

{localcode-0.5.2 → localcode-0.5.4}/README.md

@@ -1,9 +1,5 @@
 <p align="center">
-  <picture>
-    <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-dark-v2.png">
-    <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-light-v2.png">
-    <img alt="localcode" src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-light-v2.png" width="360">
-  </picture>
+  <img alt="localcode" src="https://raw.githubusercontent.com/mjwsolo/localcode/main/docs/assets/logo/lockup-dark.svg" width="360">
 </p>
 
 <p align="center">
@@ -14,8 +10,7 @@
 </p>
 
 <p align="center">
-  <strong>A coding agent that runs a local model on your Mac.</strong><br>
-  No cloud inference, no API key, no account.
+  <strong>Agentic coding. Local models. On your Mac.</strong>
 </p>
 
 <p align="center">
@@ -44,6 +39,11 @@ repository ships, with the size and whether it fits your Mac's memory. The
 recommended one for your machine is starred. Pick one, watch the download, and
 start typing. `/models` switches later.
 
+OpenJev also supports typed decisions: use `/mode` to choose **Chat** or
+**Decisions**, or run `localcode --mode decisions`. The decision screen returns
+choices, yes/no probabilities and scores without running coding tools.
+See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
+
 ```
 > Implement the retry decorator in retry.py so every test in test_retry.py passes. Then run: pytest -q
 ```

{localcode-0.5.2 → localcode-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.2"
+version = "0.5.4"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -52,6 +52,13 @@ voice = [
   "numpy>=1.26.0",
   "piper-tts>=1.2.0",         # natural neural TTS — default speaker
 ]
+# What the pre-PR checks in CONTRIBUTING.md need.
+dev = [
+  "pytest",
+  "pytest-timeout",
+  "ruff",
+  "build",
+]
 
 
 [project.urls]
@@ -77,6 +84,7 @@ where = ["src"]
     "bin/localcode-ui",
     "ui/plugin/*.ts",
     "ui/FORK_COMMIT",
+    "ui/UPSTREAM_COMMIT",
     "skills/*.md",
 ]
 
@@ -98,3 +106,8 @@ markers = [
 [tool.ruff]
 line-length = 100
 target-version = "py311"
+
+# The gate CI enforces: syntax errors, broken comparisons, undefined names.
+# Pinned here so a bare `ruff check src tests` checks the same thing locally.
+[tool.ruff.lint]
+select = ["E9", "F63", "F7", "F82"]

{localcode-0.5.2 → localcode-0.5.4}/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.2"
+    __version__ = "0.5.4"

localcode-0.5.4/src/localcode/bin/localcode-ui

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

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/config.py

@@ -129,7 +129,7 @@ class RuntimeConfig:
     llama_cpp_expert_offload: bool = False # offload MoE experts to CPU (-ot exps=CPU)
     llama_cpp_draft_model: str = ""       # path to draft GGUF for speculative decoding
     llama_cpp_lookup_cache: bool = False   # prompt lookup decoding (2-4x on code edits)
-    kv_cache_type_k: str = "q8_0"          # K cache type: q8_0, q4_0, f16, turbo2, turbo3, turbo4
+    kv_cache_type_k: str = "q8_0"          # K cache type: q8_0, q4_0, f16, turbo3, turbo4 (turbo2 is V-only; as K it runs as q8_0)
     kv_cache_type_v: str = "q8_0"          # V cache type: q8_0 default; q4_0, f16, turbo2, turbo3, turbo4 available
     llama_cpp_cache_reuse: int = 256       # --cache-reuse N: reuse KV chunks across partial prefix matches (0 = off). Recovers prefix-cache hits after mid-context edits/compaction shift the tail; the stable system-prompt prefix is already reused automatically per slot.
     llama_cpp_binary: str = ""             # custom llama-server path (e.g. TurboQuant fork)

localcode-0.5.4/src/localcode/decision.py

@@ -0,0 +1,182 @@
+"""Typed decisions on the local model service, without a chat/tool loop."""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import math
+import mimetypes
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+MAX_BYTES = 8 * 1024 * 1024
+
+
+class DecisionError(ValueError):
+    def __init__(self, message: str, status: int = 400):
+        super().__init__(message)
+        self.status = status
+
+
+def supported(alias: str | None) -> bool:
+    from .models_catalog import by_filename, group_for_filename
+    name = (alias or "").removeprefix("localcode/")
+    name = name if name.endswith(".gguf") else name + ".gguf"
+    choice = by_filename(name)
+    group = group_for_filename(name)
+    return bool((choice and choice.supports_systemone) or (group and group.supports_systemone))
+
+
+def build_request(question: str, kind: str, options: list[str], state="", images=None) -> dict:
+    types = {"yes-no": "noul", "choice": "choice", "score": "score"}
+    if kind not in types:
+        raise DecisionError("Answer type must be yes-no, choice or score")
+    item = {"type": types[kind], "instructions": question.strip()}
+    labels = [s.strip() for s in options]
+    if kind == "choice":
+        if len(labels) != len(set(labels)):
+            raise DecisionError("Each choice must have a different label")
+        item["criteria"] = {s: None for s in labels}
+    if kind == "score":
+        item["criteria"] = labels
+    if kind == "yes-no" and labels:
+        raise DecisionError("Yes/no does not use choice labels")
+    data = {"state": state, "questions": {"answer": item}}
+    if images:
+        data["images"] = images
+    return validate_request(data)
+
+
+def validate_request(data) -> dict:
+    if not isinstance(data, dict) or set(data) - {"state", "questions", "images"}:
+        raise DecisionError("Use state, questions and optional images")
+    if not isinstance(data.get("state"), (str, dict, list)):
+        raise DecisionError("Content must be text, a JSON object or a JSON array")
+    questions = data.get("questions")
+    if not isinstance(questions, dict) or not 1 <= len(questions) <= 16:
+        raise DecisionError("Supply between 1 and 16 questions")
+    for key, item in questions.items():
+        if not isinstance(key, str) or not key or len(key) > 128 or not isinstance(item, dict):
+            raise DecisionError("Questions need non-empty IDs and question objects")
+        if set(item) - {"type", "instructions", "criteria"}:
+            raise DecisionError("Questions use type, instructions and criteria")
+        instructions = item.get("instructions")
+        if not isinstance(instructions, (str, dict, list)) or not instructions:
+            raise DecisionError("A question is required")
+        kind, criteria = item.get("type"), item.get("criteria")
+        if kind == "choice":
+            if not isinstance(criteria, dict) or not 2 <= len(criteria) <= 52:
+                raise DecisionError("Choice needs 2 to 52 options")
+            if any(not isinstance(label, str) or not label.strip() or len(label) > 512 or any(ord(c) < 32 for c in label) for label in criteria):
+                raise DecisionError("Choice labels must be non-empty text without control characters")
+            if any(value is not None and not isinstance(value, str) for value in criteria.values()):
+                raise DecisionError("Choice descriptions must be text or null")
+        elif kind == "score":
+            if not isinstance(criteria, list) or not 2 <= len(criteria) <= 10 or any(not isinstance(s, str) or not s.strip() for s in criteria):
+                raise DecisionError("Score needs 2 to 10 levels, lowest to highest")
+        elif kind == "noul":
+            if criteria is not None and (not isinstance(criteria, dict) or set(criteria) - {"true", "false"} or any(not isinstance(v, str) for v in criteria.values())):
+                raise DecisionError("Yes/no criteria use true and false descriptions")
+        else:
+            raise DecisionError("Unknown question type")
+    images = data.get("images", [])
+    if not isinstance(images, list) or len(images) > 1:
+        raise DecisionError("OpenJev supports one image per decision request")
+    for value in images:
+        if not isinstance(value, str) or not value.startswith(("data:image/png;base64,", "data:image/jpeg;base64,", "data:image/webp;base64,")):
+            raise DecisionError("Images must be PNG, JPEG or WebP data URLs")
+        try:
+            base64.b64decode(value.split(",", 1)[1], validate=True)
+        except ValueError as exc:
+            raise DecisionError("Image data is not valid base64") from exc
+    try:
+        size = len(json.dumps(data, allow_nan=False).encode())
+    except (TypeError, ValueError) as exc:
+        raise DecisionError("Decision input must be valid JSON") from exc
+    if size > MAX_BYTES:
+        raise DecisionError("Decision input exceeds 8 MB", 413)
+    return data
+
+
+def validate_response(data, request) -> dict:
+    def number(value, low=0, high=1):
+        return type(value) in (float, int) and math.isfinite(value) and low <= value <= high
+
+    answers = data.get("answers") if isinstance(data, dict) else None
+    if not isinstance(answers, dict) or set(answers) != set(request["questions"]):
+        raise DecisionError("Decision server returned missing or unexpected answers", 502)
+    for key, question in request["questions"].items():
+        answer = answers[key]
+        if not isinstance(answer, dict):
+            raise DecisionError("Invalid decision answer", 502)
+        kind = question["type"]
+        if kind == "noul":
+            if not number(answer.get("noul")):
+                raise DecisionError("Invalid yes/no probability", 502)
+            continue
+        probs = answer.get("probabilities")
+        labels = set(question["criteria"]) if kind == "choice" else {str(i) for i in range(len(question["criteria"]))}
+        if not isinstance(probs, dict) or set(probs) != labels or not all(number(v) for v in probs.values()) or abs(sum(probs.values()) - 1) > 0.001:
+            raise DecisionError("Invalid decision probabilities", 502)
+        if kind == "choice" and answer.get("choice") not in labels:
+            raise DecisionError("Decision answer is not one of the supplied choices", 502)
+        if kind == "score" and not number(answer.get("score"), high=len(labels) - 1):
+            raise DecisionError("Decision score is outside the supplied levels", 502)
+    return data
+
+
+def post(url: str, body: dict, headers: dict, timeout=60) -> dict:
+    request = urllib.request.Request(url, data=json.dumps(body).encode(), headers={"Content-Type": "application/json", **headers})
+    try:
+        with urllib.request.build_opener(urllib.request.ProxyHandler({})).open(request, timeout=timeout) as response:
+            return json.load(response)
+    except urllib.error.HTTPError as exc:
+        try:
+            message = json.load(exc).get("error", "Decision request failed")
+            if isinstance(message, dict):
+                message = message.get("message", "Decision request failed")
+        except (ValueError, OSError):
+            message = "Decision request failed"
+        raise DecisionError(str(message), exc.code) from exc
+    except (OSError, ValueError) as exc:
+        raise DecisionError("The local decision service did not return a usable response", 502) from exc
+
+
+def image_url(path: Path) -> str:
+    kind = mimetypes.guess_type(path.name)[0]
+    if kind not in {"image/png", "image/jpeg", "image/webp"}:
+        raise DecisionError("Image must be PNG, JPEG or WebP")
+    if path.stat().st_size > 5 * 1024 * 1024:
+        raise DecisionError("Image exceeds 5 MB", 413)
+    return "data:" + kind + ";base64," + base64.b64encode(path.read_bytes()).decode()
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(prog="localcode decide", description="Ask the loaded decision model a typed question; no coding tools are executed.")
+    parser.add_argument("--question", required=True)
+    parser.add_argument("--type", choices=["yes-no", "choice", "score"], default="yes-no", dest="kind")
+    parser.add_argument("--option", action="append", default=[], help="Choice label or ordered score level; repeat for each")
+    inputs = parser.add_mutually_exclusive_group()
+    inputs.add_argument("--state", default="", help="Content to evaluate (optional)")
+    inputs.add_argument("--state-file", type=Path, help="Read content from a UTF-8 file")
+    parser.add_argument("--image", type=Path, help="Optional image")
+    args = parser.parse_args(argv)
+    try:
+        state = args.state_file.read_text() if args.state_file else args.state
+        body = build_request(args.question, args.kind, args.option, state, [image_url(args.image)] if args.image else None)
+        from .ui.auth import control_headers, read_auth_file
+        from .ui import run_dir
+        from .ui.ports import find_running
+        running = find_running()
+        credentials = read_auth_file(run_dir())
+        if running is None or credentials is None:
+            raise DecisionError("Start LocalCode and load OpenJev before using decide", 409)
+        data = post(f"http://127.0.0.1:{running[0]}/decision", body, control_headers(credentials[0]))
+        validate_response(data, body)
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+        return 0
+    except (DecisionError, OSError) as exc:
+        print("localcode decide: " + str(exc), file=sys.stderr)
+        return 1

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/entrypoint.py

@@ -11,9 +11,10 @@ def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="localcode",
         description="LocalCode — AI coding assistant running entirely on your machine",
-        epilog="Other command: localcode api [--json] [--show-key] shows the running model endpoint.",
+        epilog="Other commands: localcode api shows connection details; localcode decide asks a typed question.",
     )
     parser.add_argument("--version", action="store_true", help="Print the version and exit")
+    parser.add_argument("--mode", choices=["chat", "decisions"], default="chat", help="Start in normal chat or typed decision mode")
     parser.add_argument("--model", help="Model alias to load (otherwise the picker asks)")
     parser.add_argument("-s", "--session", "--resume", dest="resume", metavar="SESSION_ID",
                         help="Resume a session by ID; uses its saved project directory when no project is given")
@@ -34,6 +35,9 @@ def _unsupported_platform_message() -> str:
 
 def main(argv: list[str] | None = None) -> None:
     argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] == "decide":
+        from .decision import main as decide_main
+        sys.exit(decide_main(argv[1:]))
     if argv and argv[0] == "api":
         from .ui.api import main as api_main
         sys.exit(api_main(argv[1:]))
@@ -44,6 +48,7 @@ def main(argv: list[str] | None = None) -> None:
         os.environ.pop(var, None)
 
     args = build_parser().parse_args(argv)
+    os.environ["LOCALCODE_MODE"] = args.mode
 
     if args.version:
         from . import __version__

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/model_families.py

@@ -251,6 +251,9 @@ def infer_family_from_profile(profile_id: str) -> ModelFamily:
     # Hermes <tool_call> JSON. Same adapter.
     if "kolibri" in low:
         return ModelFamily.QWEN
+    # OpenJev is a Qwen 3.5 fine-tune and keeps its chat template.
+    if "openjev" in low:
+        return ModelFamily.QWEN
     if low.startswith("llama") or "llama" in low:
         return ModelFamily.LLAMA
     if low.startswith("deepseek") or "deepseek" in low:

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/models_catalog.py

@@ -98,6 +98,7 @@ class ModelChoice:
     reasoning_budget_tokens: int = 8192
     preserves_reasoning: bool = True
     supports_parallel_tools: bool = False
+    supports_systemone: bool = False
 
     @property
     def hf_url(self) -> str:
@@ -450,6 +451,36 @@ CHOICES: list[ModelChoice] = [
         # tokens, empty reasoning channel). That is the default policy
         # ("chat_template"), the same one the Gemma 4 and Qwen entries use.
     ),
+    ModelChoice(
+        key="openjev",
+        supports_systemone=True,
+        # Pinned to the revision and digest that were verified live.
+        revision="10840f375658dea7afc5ff4711127bca8218b560",
+        sha256="38b512277edaeec6cd251d146bff6d97bc328fa9db19755401d6e9ab1ccbcba5",
+        size_bytes=18973872288,
+        name="OpenJev 27B (Q4, decision model)",
+        hf_repo="ggml-org/OpenJev-GGUF",
+        filename="OpenJev-Q4_K_M.gguf",
+        size_gb=19.0,
+        active_params="27B dense (Qwen 3.5 base, tuned for typed decisions)",
+        architecture="qwen35",
+        license="CC BY-NC 4.0 (non-commercial use only)",
+        humaneval_pass_at_1=None,
+        notes=(
+            "A DECISION model, not a coding model. It answers typed questions "
+            "about a state (text, JSON, a web page, a screenshot) with a choice, "
+            "a yes/no probability or a score, in one forward pass per question, "
+            "through the bundled server's /v1/systemone endpoint; `localcode api` "
+            "prints the endpoint and key. It also answers on the chat endpoint, "
+            "but it was tuned for decisions and is not benchmarked for coding. "
+            "The weights are CC BY-NC 4.0: research and non-commercial use only. "
+            "Needs ~32 GB unified memory. Pair with the mmproj for screenshot "
+            "input. Never auto-recommended."
+        ),
+        mmproj_filename="mmproj-OpenJev-Q8_0.gguf",
+        mmproj_size_gb=0.6,
+        mmproj_hf_filename="mmproj-OpenJev-Q8_0.gguf",
+    ),
 ]
 
 
@@ -488,6 +519,14 @@ def _system_ram_gb() -> int:
 # it is not the coding-agent experience a first-run user should land on by
 # default. Owner can override by emptying this set.
 _NO_AUTO_RECOMMEND_ARCHS = {"diffusion_gemma", "kolibri1"}
+# Entries excluded by key, for models that share an architecture with a
+# recommended one: OpenJev is a qwen35 like Qwen 3.8, but it is a decision
+# model and must never be a first-run coding default.
+_NO_AUTO_RECOMMEND_KEYS = {"openjev"}
+
+
+def _auto_recommendable(c: "ModelChoice") -> bool:
+    return c.architecture not in _NO_AUTO_RECOMMEND_ARCHS and c.key not in _NO_AUTO_RECOMMEND_KEYS
 
 # 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
@@ -526,14 +565,14 @@ def recommend(ram_gb: int | None = None) -> ModelChoice:
     budget = ram_gb * 0.55
     candidates = [
         c for c in CHOICES
-        if c.architecture not in _NO_AUTO_RECOMMEND_ARCHS and c.size_gb <= budget
+        if _auto_recommendable(c) and c.size_gb <= budget
     ]
     if candidates:
         # Most capable that fits; tie-break toward the larger (better-quant) file.
         return min(candidates, key=lambda c: (_capability_rank(c), -c.size_gb))
     # Nothing fits the budget — smallest production-ready model so the user still
     # gets something runnable rather than an impossible recommendation.
-    prod = [c for c in CHOICES if c.architecture not in _NO_AUTO_RECOMMEND_ARCHS]
+    prod = [c for c in CHOICES if _auto_recommendable(c)]
     return min(prod or CHOICES, key=lambda c: c.size_gb)
 
 
@@ -636,6 +675,8 @@ class ModelGroup:
     mmproj_size_gb: float = 0.0
     mmproj_hf_filename: str | None = None
 
+    supports_systemone: bool = False
+
     @property
     def supports_vision(self) -> bool:
         return self.mmproj_filename is not None
@@ -785,6 +826,24 @@ MODEL_GROUPS: list[ModelGroup] = [
             "Text-only."
         ),
     ),
+    ModelGroup(
+        key="openjev",
+        supports_systemone=True,
+        display_name="OpenJev 27B (decision model)",
+        maker="OpenJev",
+        hf_repo="ggml-org/OpenJev-GGUF",
+        family="qwen",
+        architecture="qwen35",
+        license="CC BY-NC 4.0 (non-commercial use only)",
+        notes=(
+            "Decision model, not a coding model: typed choice / yes-no / score "
+            "answers about text, web pages and screenshots through /v1/systemone. "
+            "Q4_K_M, Q8_0 and BF16 quants. Non-commercial licence."
+        ),
+        mmproj_filename="mmproj-OpenJev-Q8_0.gguf",
+        mmproj_size_gb=0.6,
+        mmproj_hf_filename="mmproj-OpenJev-Q8_0.gguf",
+    ),
 ]
 
 
@@ -838,6 +897,7 @@ def choice_for_quant(group: ModelGroup, filename: str, size_gb: float) -> ModelC
         mmproj_filename=group.mmproj_filename,
         mmproj_size_gb=group.mmproj_size_gb,
         mmproj_hf_filename=group.mmproj_hf_filename,
+        supports_systemone=group.supports_systemone,
         reasoning_control=canonical.reasoning_control if canonical else "chat_template",
         reasoning_budget_tokens=canonical.reasoning_budget_tokens if canonical else 8192,
         preserves_reasoning=canonical.preserves_reasoning if canonical else True,

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/runtime.py

@@ -466,6 +466,12 @@ class LocalCodeRuntimeGateway:
         # KV cache compression (asymmetric: q8_0 K + turbo4 V recommended)
         ctk = self.config.kv_cache_type_k
         ctv = self.config.kv_cache_type_v
+        # turbo2 is a VALUE type only. Two bits per key leaves each key about a
+        # third off its true direction, which attention cannot absorb: measured
+        # perplexity roughly doubles, identically on the CPU reference and on
+        # Metal (llama-cpp-turboquant/PATCHES.md). Keys fall back to q8_0.
+        if (ctk or "").lower() == "turbo2":
+            ctk = "q8_0"
         if ctk and ctk != "f16":
             cmd.extend(["--cache-type-k", ctk])
         if ctv and ctv != "f16":

localcode-0.5.4/src/localcode/ui/UPSTREAM_COMMIT

@@ -0,0 +1 @@
+907b3bc518fa48e90e8ec24dd327d13eee71c36c

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/ui/auth.py

@@ -92,3 +92,14 @@ def request_allowed(headers, expected_token: str, port: int, *, want_json: bool
         if ctype != "application/json":
             return "Content-Type must be application/json"
     return None
+
+
+def redact_command(command: list[str]) -> list[str]:
+    """Keep the server key out of diagnostic logs."""
+    redacted = list(command)
+    for i, value in enumerate(redacted):
+        if value == "--api-key" and i + 1 < len(redacted):
+            redacted[i + 1] = "[redacted]"
+        elif value.startswith("--api-key="):
+            redacted[i] = "--api-key=[redacted]"
+    return redacted

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/ui/launch.py

@@ -126,6 +126,12 @@ def write_config(path: Path, *, port: int, ctx: int, alias: str | None) -> None:
     tmp = path.with_suffix(".json.tmp")
     tmp.write_text(json.dumps(cfg, indent=2))
     os.replace(tmp, path)
+    # Keep terminal-only UI extensions separate from server/tool hooks. The
+    # pinned runtime supports this through its native TUI plugin config.
+    tui_path = path.with_suffix(".tui.json")
+    tui_tmp = tui_path.with_suffix(".json.tmp")
+    tui_tmp.write_text(json.dumps({"plugin": [str(plugin_path().with_name("modes.ts"))]}))
+    os.replace(tui_tmp, tui_path)
 
 
 def _resume_args(resume: str | None) -> list[str]:
@@ -180,6 +186,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
     env = dict(os.environ)
     env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
     env["LOCALCODE_CONFIG"] = str(config_path)
+    env["OPENCODE_TUI_CONFIG"] = str(config_path.with_suffix(".tui.json"))
     env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
     argv = [str(ui_bin)] + (["-m", f"localcode/{current}"] if current else []) + _resume_args(resume)
     try:
@@ -284,6 +291,7 @@ def main(model: str | None = None, project: str | None = None,
         env = dict(os.environ)
         env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
         env["LOCALCODE_CONFIG"] = str(config_path)
+        env["OPENCODE_TUI_CONFIG"] = str(config_path.with_suffix(".tui.json"))
         # Language servers are installed only on request (/lsp), never silently.
         env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
         argv = [str(ui_bin)]

{localcode-0.5.2 → localcode-0.5.4}/src/localcode/ui/plugin/localcode.ts

@@ -635,7 +635,7 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
           if (output.system[i].includes("__pending__")) output.system[i] = output.system[i].replaceAll("__pending__", loaded);
         }
       }
-      if (input.agent && input.agent !== "build") return;
+      const isBuild = !input.agent || input.agent === "build";
       // The system prompt must be IDENTICAL for every request of a session: it
       // is the cached prefix. This rule used to be added only once
       // workspaceActive flipped (after the first tool call of each turn), so the
@@ -643,7 +643,14 @@ const LocalcodePlugin: Plugin = async ({ client, directory }) => {
       // once per turn (15-23 s at 30k tokens). It is inert in plain chat (the
       // gates check workspaceActive in code), so always add it. The open-todo
       // list is not put here either: it rides on the user turn (chat.message).
-      output.system.push(PLANNING_RULE);
+      if (isBuild) output.system.push(PLANNING_RULE);
+      // The runtime maps every entry to a separate system message. OpenJev's
+      // template accepts exactly one, at the beginning; a second one raises
+      // "System message must be at the beginning" before inference. Preserve
+      // every instruction in order in a single prefix for every agent.
+      if (output.system.length > 1) {
+        output.system.splice(0, output.system.length, output.system.join("\n\n"));
+      }
     },
 
     "chat.message": async (input, output) => {