localcode 0.5.3__tar.gz → 0.5.5__tar.gz

{localcode-0.5.3/src/localcode.egg-info → localcode-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.3
+Version: 0.5.5
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -47,11 +47,7 @@ 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">
@@ -62,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">
@@ -92,6 +87,14 @@ 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.
 
+Project plugins and configuration load only with `localcode --trust-project`.
+Use it after reviewing the project's startup code and settings.
+
+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.3 → localcode-0.5.5}/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,14 @@ 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.
 
+Project plugins and configuration load only with `localcode --trust-project`.
+Use it after reviewing the project's startup code and settings.
+
+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.3 → localcode-0.5.5}/pyproject.toml

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

{localcode-0.5.3 → localcode-0.5.5}/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.3"
+    __version__ = "0.5.5"

localcode-0.5.5/src/localcode/bin/localcode-ui

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

localcode-0.5.5/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.3 → localcode-0.5.5}/src/localcode/entrypoint.py

@@ -11,9 +11,11 @@ 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("--trust-project", action="store_true", help="Allow this project's configuration, plugins and MCP startup commands to load")
     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 +36,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 +49,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__
@@ -67,7 +73,7 @@ def main(argv: list[str] | None = None) -> None:
               "Reinstall with `pip install -U localcode`.", file=sys.stderr)
         sys.exit(1)
     from .ui.launch import main as ui_main
-    sys.exit(ui_main(args.model, project=project, resume=args.resume))
+    sys.exit(ui_main(args.model, project=project, resume=args.resume, trust_project=args.trust_project))
 
 
 if __name__ == "__main__":

{localcode-0.5.3 → localcode-0.5.5}/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:
@@ -452,6 +453,7 @@ CHOICES: list[ModelChoice] = [
     ),
     ModelChoice(
         key="openjev",
+        supports_systemone=True,
         # Pinned to the revision and digest that were verified live.
         revision="10840f375658dea7afc5ff4711127bca8218b560",
         sha256="38b512277edaeec6cd251d146bff6d97bc328fa9db19755401d6e9ab1ccbcba5",
@@ -673,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
@@ -824,6 +828,7 @@ MODEL_GROUPS: list[ModelGroup] = [
     ),
     ModelGroup(
         key="openjev",
+        supports_systemone=True,
         display_name="OpenJev 27B (decision model)",
         maker="OpenJev",
         hf_repo="ggml-org/OpenJev-GGUF",
@@ -892,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.3 → localcode-0.5.5}/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]:
@@ -155,8 +161,23 @@ def _session_directory(session_id: str) -> Path | None:
     return None
 
 
+def runtime_env(config_path: Path, ctrl: int, *, trust_project: bool = False) -> dict[str, str]:
+    """Project configuration can execute code before tool permissions apply."""
+    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"))
+    # The branded alias takes precedence in the fork. Set both explicitly so
+    # an inherited alias cannot accidentally reopen project code loading.
+    disabled = "0" if trust_project else "1"
+    env["LOCALCODE_DISABLE_PROJECT_CONFIG"] = disabled
+    env["OPENCODE_DISABLE_PROJECT_CONFIG"] = disabled
+    env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+    return env
+
+
 def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str | None,
-           resume: str | None = None) -> int:
+           resume: str | None = None, *, trust_project: bool = False) -> int:
     """Open another UI window on the model server a running session owns."""
     # The running session's secrets, left owner-only in the run directory.
     auth = read_auth_file(run_dir())
@@ -177,10 +198,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
     rd.mkdir(parents=True, exist_ok=True)
     config_path = rd / f"session-{os.getpid()}.json"
     write_config(config_path, port=port, ctx=ctx, alias=current)
-    env = dict(os.environ)
-    env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
-    env["LOCALCODE_CONFIG"] = str(config_path)
-    env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+    env = runtime_env(config_path, ctrl, trust_project=trust_project)
     argv = [str(ui_bin)] + (["-m", f"localcode/{current}"] if current else []) + _resume_args(resume)
     try:
         return subprocess.call(argv, cwd=str(project_dir), env=env)
@@ -192,7 +210,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
 
 
 def main(model: str | None = None, project: str | None = None,
-         resume: str | None = None) -> int:
+         resume: str | None = None, *, trust_project: bool = False) -> int:
     ui_bin = ui_binary_path()
     if ui_bin is None:
         print("localcode: the UI binary is missing from this install. "
@@ -218,7 +236,8 @@ def main(model: str | None = None, project: str | None = None,
     # instead of refusing. One llama-server per machine, any number of windows.
     running = find_running()
     if running is not None:
-        return attach(running[0], running[1], ui_bin, project_dir, alias, resume)
+        return attach(running[0], running[1], ui_bin, project_dir, alias, resume,
+                      trust_project=trust_project)
 
     try:
         port, ctrl = choose_ports()
@@ -281,11 +300,7 @@ def main(model: str | None = None, project: str | None = None,
         config_path = rd / "session.json"
         write_config(config_path, port=port, ctx=ctx, alias=alias)
 
-        env = dict(os.environ)
-        env["LOCALCODE_CONTROL_URL"] = f"http://127.0.0.1:{ctrl}"
-        env["LOCALCODE_CONFIG"] = str(config_path)
-        # Language servers are installed only on request (/lsp), never silently.
-        env.setdefault("OPENCODE_DISABLE_LSP_DOWNLOAD", "1")
+        env = runtime_env(config_path, ctrl, trust_project=trust_project)
         argv = [str(ui_bin)]
         if alias:
             argv += ["-m", f"localcode/{alias}"]

localcode-0.5.5/src/localcode/ui/plugin/modes.ts

@@ -0,0 +1,186 @@
+/** Terminal-only mode chooser using the pinned OpenCode TUI extension API. */
+import type { TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui";
+
+type Kind = "yes-no" | "choice" | "score";
+type Status = { state: string; current?: string; supports_systemone?: boolean };
+type Answer = { choice?: string; noul?: number; score?: number; probabilities?: Record<string, number>; legend?: Record<string, string> | string[] };
+type Result = { model: string; answers: Record<string, Answer>; usage?: { input_tokens?: number; output_tokens?: number } };
+type Form = { question: string; state: string; kind: Kind; options: string; image: string };
+const route = "localcode.decisions";
+
+export function requestFor(form: Form) {
+  if (!form.question.trim()) throw new Error("Enter a question first");
+  const options = form.options.split("\n").map((s) => s.trim()).filter(Boolean);
+  if (form.kind === "choice" && (options.length < 2 || options.length > 52 || new Set(options).size !== options.length)) {
+    throw new Error("Enter 2 to 52 different choices, one per line");
+  }
+  if (form.kind === "score" && (options.length < 2 || options.length > 10)) {
+    throw new Error("Enter 2 to 10 levels, one per line, lowest to highest");
+  }
+  const question = {
+    type: form.kind === "yes-no" ? "noul" : form.kind,
+    instructions: form.question.trim(),
+    ...(form.kind === "choice" ? { criteria: Object.fromEntries(options.map((label) => [label, null])) } : {}),
+    ...(form.kind === "score" ? { criteria: options } : {}),
+  };
+  return { state: form.state, questions: { answer: question } };
+}
+
+export function answerRows(result: Result) {
+  const answer = result.answers.answer;
+  if (!answer) throw new Error("Decision response has no answer");
+  if (answer.noul !== undefined) return [
+    { title: "Yes", value: "result:yes", footer: `${(answer.noul * 100).toFixed(1)}%`, category: "Result" },
+    { title: "No", value: "result:no", footer: `${((1 - answer.noul) * 100).toFixed(1)}%`, category: "Result" },
+  ];
+  return Object.entries(answer.probabilities ?? {}).sort((a, b) => b[1] - a[1]).map(([label, value]) => ({
+    title: (Array.isArray(answer.legend) ? answer.legend[Number(label)] : answer.legend?.[label]) ?? (label + (label === answer.choice ? " ✓" : "")), value: "result:" + label,
+    footer: `${(value * 100).toFixed(1)}%`, category: "Result",
+  }));
+}
+
+async function tui(api: TuiPluginApi) {
+  let previous: { name: string; params?: Record<string, unknown> } = { name: "home" };
+  let form: Form = { question: "", state: "", kind: "yes-no", options: "", image: "" };
+  let status: Status | undefined;
+  let result: Result | undefined;
+  let busy = false;
+  let revision = 0;
+  let pending: AbortController | undefined;
+  const control = (process.env.LOCALCODE_CONTROL_URL ?? "").replace(/\/$/, "");
+  const headers = { "content-type": "application/json", "x-localcode-token": process.env.LOCALCODE_CONTROL_TOKEN ?? "" };
+  const error = (message: string) => api.ui.toast({ variant: "error", message, duration: 8000 });
+  const refresh = () => {
+    if (api.route.current.name === route) api.route.navigate(route, { revision: ++revision });
+  };
+  const back = () => {
+    pending?.abort();
+    api.ui.dialog.clear();
+    api.route.navigate(previous.name, previous.params);
+  };
+  async function poll() {
+    if (api.route.current.name !== route || !control) return;
+    try {
+      const response = await fetch(control + "/status", { headers, signal: AbortSignal.timeout(2000) });
+      if (!response.ok) return;
+      const data = await response.json() as Status;
+      const next = { state: data.state, current: data.current, supports_systemone: data.supports_systemone };
+      if (JSON.stringify(next) === JSON.stringify(status)) return;
+      status = next;
+      refresh();
+    } catch { /* Status is retried; explicit evaluation reports failures. */ }
+  }
+  function open() {
+    if (api.route.current.name !== route) {
+      const current = api.route.current;
+      previous = current.name === "session" ? { name: "session", params: { ...current.params } } : { name: "home" };
+    }
+    api.ui.dialog.clear();
+    api.route.navigate(route, { revision: ++revision });
+    void poll();
+  }
+  function edit(key: "question" | "state" | "options" | "image", title: string) {
+    api.ui.dialog.replace(() => api.ui.DialogPrompt({ title, value: form[key], onConfirm(value) {
+      form = { ...form, [key]: value };
+      result = undefined;
+      api.ui.dialog.clear();
+      refresh();
+    } }));
+  }
+  function kind() {
+    api.ui.dialog.replace(() => api.ui.DialogSelect<Kind>({ title: "Answer type", current: form.kind, options: [
+      { title: "Yes / no", value: "yes-no", description: "Probability of yes and no" },
+      { title: "Choice", value: "choice", description: "Pick from your own labels" },
+      { title: "Score", value: "score", description: "Ordered levels, lowest to highest" },
+    ], onSelect(option) {
+      form = { ...form, kind: option.value };
+      result = undefined;
+      api.ui.dialog.clear();
+      refresh();
+    } }));
+  }
+  async function evaluate() {
+    if (busy) return;
+    busy = true;
+    result = undefined;
+    const controller = new AbortController();
+    pending = controller;
+    refresh();
+    try {
+      const body: ReturnType<typeof requestFor> & { images?: string[] } = requestFor(form);
+      if (form.image.trim()) {
+        const file = Bun.file(form.image.trim().replace(/^~\//, (process.env.HOME ?? "") + "/"));
+        if (file.size > 5 * 1024 * 1024) throw new Error("Image exceeds 5 MB");
+        const ext = form.image.trim().split(".").at(-1)?.toLowerCase();
+        const mime = ext === "png" ? "image/png" : ext === "webp" ? "image/webp" : ["jpg", "jpeg"].includes(ext ?? "") ? "image/jpeg" : "";
+        if (!mime) throw new Error("Image must be PNG, JPEG or WebP");
+        body.images = [`data:${mime};base64,${Buffer.from(await file.arrayBuffer()).toString("base64")}`];
+      }
+      if (controller.signal.aborted) return;
+      const response = await fetch(control + "/decision", { method: "POST", headers, body: JSON.stringify(body), signal: AbortSignal.any([controller.signal, AbortSignal.timeout(65000)]) });
+      const data = await response.json();
+      if (!response.ok) throw new Error(data.error ?? "Decision request failed");
+      if (api.route.current.name !== route) return;
+      result = data as Result;
+    } catch (cause) {
+      if (api.route.current.name === route) error(cause instanceof Error ? cause.message : "Decision request failed");
+    } finally {
+      busy = false;
+      pending = undefined;
+      refresh();
+    }
+  }
+  api.route.register([{ name: route, render(input) {
+    // The host uses a reactive route store; reading the revision redraws fields
+    // without persisting user content in the global settings database.
+    void input.params?.revision;
+    const rows = [
+      { title: "Model: " + (status?.current ?? "none loaded"), value: "model", description: status?.supports_systemone ? "Ready for decisions" : "Select OpenJev with /models", category: "Decisions" },
+      { title: "Question", value: "question", description: form.question || "What should the model decide?", category: "Input" },
+      { title: "Content (optional)", value: "state", description: form.state.slice(0, 60) || "Text or JSON to evaluate", category: "Input" },
+      { title: "Answer type: " + form.kind, value: "kind", category: "Input" },
+      ...(form.kind === "yes-no" ? [] : [{ title: form.kind === "score" ? "Levels (lowest to highest)" : "Choices", value: "options", description: form.options.replaceAll("\n", " · ") || "Enter one per line", category: "Input" }]),
+      { title: "Image (optional)", value: "image", description: form.image || "PNG, JPEG or WebP file path", category: "Input" },
+      { title: busy ? "Evaluating…" : "Run decision", value: "run", category: "Actions" },
+      ...(result ? [{ title: "Answered by " + result.model, value: "result:model", description: "Prediction only; no tools or code actions executed", category: "Result" }, ...answerRows(result), ...(result.answers.answer.score === undefined ? [] : [{ title: "Score", value: "result:score", footer: result.answers.answer.score.toFixed(3), category: "Result" }])] : []),
+      { title: "Back to chat", value: "chat", category: "Actions" },
+    ];
+    return api.ui.Dialog({ size: "large", onClose: back, children: api.ui.DialogSelect({ title: "Decisions · System One", placeholder: "Choose a field or action", options: rows, skipFilter: true, onSelect(item) {
+      if (item.value === "chat") return back();
+      if (busy) return;
+      if (item.value === "model") return api.keymap.dispatchCommand("model.list");
+      if (item.value === "kind") return kind();
+      if (item.value === "question") return edit("question", "Decision question");
+      if (item.value === "state") return edit("state", "Content to evaluate (optional)");
+      if (item.value === "options") return edit("options", form.kind === "score" ? "Levels: lowest to highest, one per line" : "Choices: one per line");
+      if (item.value === "image") return edit("image", "Image file path (optional)");
+      if (item.value === "run") {
+        if (status?.state !== "ready" || status?.supports_systemone !== true) return error("Select a decision model such as OpenJev using the Model row first");
+        void evaluate();
+      }
+    } }) });
+  } }]);
+  const choose = () => api.ui.dialog.replace(() => api.ui.DialogSelect({ title: "LocalCode mode", current: api.route.current.name === route ? "decisions" : "chat", options: [
+    { title: "Chat", value: "chat", description: "Ask questions and work on code" },
+    { title: "Decisions", value: "decisions", description: "Typed choices, yes/no probabilities and scores" },
+  ], onSelect(item) {
+    if (item.value === "decisions") return open();
+    if (api.route.current.name === route) return back();
+    api.ui.dialog.clear();
+  } }));
+  api.keymap.registerLayer({ commands: [
+    { name: "localcode.mode", title: "Choose Chat or Decisions", category: "LocalCode", slash: { name: "mode" }, run: choose },
+    { name: "localcode.decide", title: "Open decision mode", category: "LocalCode", slash: { name: "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);
+  let startup: ReturnType<typeof setInterval> | undefined;
+  if (process.env.LOCALCODE_MODE === "decisions") startup = setInterval(() => {
+    if (!api.state.ready) return;
+    clearInterval(startup);
+    open();
+  }, 100);
+  api.lifecycle.onDispose(() => { clearInterval(timer); clearInterval(startup); pending?.abort(); });
+}
+
+export default { id: "localcode.modes", tui } satisfies TuiPluginModule;