lcode-cli 0.14.0__tar.gz → 0.16.0__tar.gz

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/CHANGELOG.md

@@ -6,6 +6,40 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.16.0] - 2026-10-05
+
+### Added
+
+- Other model servers: LM Studio, llama.cpp's llama-server, vLLM, MLX's server, or any other
+  server with an OpenAI-compatible API, instead of Ollama. `lcode config set backend lmstudio` (or
+  `llama.cpp`, `vllm`, `mlx`, `openai` with `base_url`); a key can come from `LCODE_API_KEY`. Tool
+  calls, streaming, reasoning (on and off), images and structured answers work as with Ollama.
+  lcode reads the context window from the server, matches the model setting to the models it
+  serves, and moves thinking that a server sends as part of the answer out of it. `lcode doctor`,
+  `lcode models`, `lcode bench` and `lcode index` work with every backend. See
+  [Other model servers](https://nasser1941.github.io/lcode/servers/), with setup for each.
+
+## [0.15.0] - 2026-10-05
+
+### Added
+
+- Hooks: shell commands that run on lcode's events (`before_tool`, `after_tool`, `after_request`,
+  `session_start`, `notification`), filtered by tool and file, with the event as JSON on stdin. A
+  `before_tool` hook that exits with code 2 blocks the call and tells the model why; an
+  `after_tool` hook's output reaches the model when it fails (a linter) or with `feedback = true`.
+  Notification hooks run when lcode waits for you and when a long request is done.
+- Permission rules: `[permissions]` allow and deny lists for shell commands, file edits, web
+  domains and MCP tools, checked before lcode asks. Deny always wins, even in `yolo` mode and for
+  read-only commands, and is enforced for subagents too.
+- Both go in `config.toml` or a repository's `.lcode/settings.toml`, which is used only once
+  approved (and approved again after any change). `lcode doctor` lists them. See
+  [Hooks and permission rules](https://nasser1941.github.io/lcode/hooks/), with recipes for ruff,
+  prettier, blocking force-pushes, running tests and desktop notifications.
+
+### Fixed
+
+- `lcode config set` no longer drops tables you added to `config.toml` by hand.
+
 ## [0.14.0] - 2026-10-05
 
 ### Added
@@ -364,7 +398,9 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.14.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.16.0...HEAD
+[0.16.0]: https://github.com/nasser1941/lcode/compare/v0.15.0...v0.16.0
+[0.15.0]: https://github.com/nasser1941/lcode/compare/v0.14.0...v0.15.0
 [0.14.0]: https://github.com/nasser1941/lcode/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/nasser1941/lcode/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/nasser1941/lcode/compare/v0.11.1...v0.12.0

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.14.0
+Version: 0.16.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/
@@ -89,6 +89,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   and sees the errors an edit introduced right away.
 - **Commands and skills.** Your own `/commands` as prompt templates, and skills in the
   [Agent Skills](https://agentskills.io) format that the model loads only when a task needs them.
+- **Hooks and rules.** Format every edited file, block force-pushes, run the tests after each
+  request: shell hooks on lcode's events, and allow and deny lists that hold even in `yolo` mode.
 - **Plan mode.** `/plan <request>` or Shift+Tab: the model explores read-only and presents a plan;
   you approve, edit or send it back before anything changes.
 - **Undo.** lcode saves a checkpoint before the model changes files; `/undo` takes back the last
@@ -100,7 +102,7 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
   of a session. Not whole conversations, and never secrets.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
-  with tool calling.
+  with tool calling. Or use LM Studio, llama.cpp, vLLM or MLX instead of Ollama.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
   Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes, Metabase, Encord, Valohai and more with one command
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
@@ -206,7 +208,8 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)
+- [Git workflow: /commit, /review, /pr and parallel worktrees](https://github.com/nasser1941/lcode/issues/50)
+- [Automation: JSON output, a Python API and a GitHub Action for self-hosted runners](https://github.com/nasser1941/lcode/issues/48)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/README.md

@@ -53,6 +53,8 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   and sees the errors an edit introduced right away.
 - **Commands and skills.** Your own `/commands` as prompt templates, and skills in the
   [Agent Skills](https://agentskills.io) format that the model loads only when a task needs them.
+- **Hooks and rules.** Format every edited file, block force-pushes, run the tests after each
+  request: shell hooks on lcode's events, and allow and deny lists that hold even in `yolo` mode.
 - **Plan mode.** `/plan <request>` or Shift+Tab: the model explores read-only and presents a plan;
   you approve, edit or send it back before anything changes.
 - **Undo.** lcode saves a checkpoint before the model changes files; `/undo` takes back the last
@@ -64,7 +66,7 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
   of a session. Not whole conversations, and never secrets.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
-  with tool calling.
+  with tool calling. Or use LM Studio, llama.cpp, vLLM or MLX instead of Ollama.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
   Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes, Metabase, Encord, Valohai and more with one command
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
@@ -170,7 +172,8 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)
+- [Git workflow: /commit, /review, /pr and parallel worktrees](https://github.com/nasser1941/lcode/issues/50)
+- [Automation: JSON output, a Python API and a GitHub Action for self-hosted runners](https://github.com/nasser1941/lcode/issues/48)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/bench.md

@@ -12,6 +12,10 @@ lcode bench --json results.json       # also save machine-readable results
 lcode bench --markdown                # also print a table to paste into a test report
 ```
 
+`lcode bench` also runs against [other model servers](servers.md), such as llama-server or LM
+Studio: `LCODE_BACKEND=llama.cpp lcode bench`. The server keeps the model loaded and doesn't report
+its memory use, so those columns stay empty.
+
 ```text
 lcode bench · NVIDIA GeForce RTX 4080 Laptop GPU (12 GB VRAM), 31 GB RAM · Ollama 0.32.15
 
@@ -158,6 +162,7 @@ existing fields keep their meaning until `schema` changes.
   "schema": 1,
   "lcode": "0.3.1",
   "ollama": "0.32.15",
+  "server": "Ollama 0.32.15",
   "date": "2026-09-30T19:09:09+02:00",
   "hardware": {
     "os": "linux", "cpu": "13th Gen Intel(R) Core(TM) i9-13980HX", "ram_gib": 30.96,
@@ -197,6 +202,7 @@ existing fields keep their meaning until `schema` changes.
 
 | Field | Meaning |
 |---|---|
+| `ollama`, `server` | The Ollama version, or `null` with [another model server](servers.md); `server` names the server either way |
 | `runs[].model` | The name you gave (catalog key or Ollama tag); `ollama_model` is the model that ran |
 | `runs[].context`, `num_batch`, `think` | The settings used. lcode lowers the batch size or context if the GPU runs out of memory, and reports what it ended up using |
 | `runs[].memory_gb`, `gpu_percent` | From Ollama's `/api/ps`; `null` if unavailable |

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/configuration.md

@@ -15,11 +15,13 @@ lcode config path                      # print the file location
 
 | Setting | Default | Meaning |
 |---|---|---|
-| `model` | `qwen3.6-35b` | Catalog key (see `lcode models`) or any installed Ollama model tag |
+| `model` | `qwen3.6-35b` | Catalog key (see `lcode models`) or any installed Ollama model tag; with another [backend](servers.md), a model the server serves |
 | `context` | largest that fits | Context window in tokens; accepts `128k`, `1m` |
 | `num_batch` | 512 | Prompt batch size. Larger reads prompts faster but needs more GPU memory |
 | `keep_alive` | `30m` | How long Ollama keeps the model in memory after the last request |
 | `ollama_host` | `http://localhost:11434` | Ollama server URL |
+| `backend` | `ollama` | The model server: `ollama`, `lmstudio`, `llama.cpp`, `vllm`, `mlx` or `openai` (any OpenAI-compatible API); see [Other model servers](servers.md) |
+| `base_url` | the backend's | The server's OpenAI-compatible address, e.g. `http://localhost:1234/v1` |
 | `permission_mode` | `ask` | `ask`, `plan`, `auto-edit` or `yolo` |
 | `think` | `true` | Let the model reason before answering |
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |
@@ -40,6 +42,10 @@ lcode config path                      # print the file location
 | `max_parallel_agents` | `1` | Subagents that run at the same time; more needs `OLLAMA_NUM_PARALLEL` on the Ollama server ([details](agents.md#several-at-once)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
+Besides these settings, `config.toml` can hold [hooks](hooks.md) (`[[hooks]]`) and
+[permission rules](hooks.md#permission-rules) (`[permissions]`); a repository can have its own in
+`.lcode/settings.toml`. `lcode config set` keeps them when it rewrites the file.
+
 Example file:
 
 ```toml
@@ -61,6 +67,9 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `LCODE_NUM_BATCH` | `num_batch` |
 | `LCODE_KEEP_ALIVE` | `keep_alive` |
 | `OLLAMA_HOST` | `ollama_host` (same variable the Ollama CLI uses) |
+| `LCODE_BACKEND` | `backend` |
+| `LCODE_BASE_URL` | `base_url` |
+| `LCODE_API_KEY` or `OPENAI_API_KEY` | API key for an [OpenAI-compatible server](servers.md) that needs one (never stored in the config file) |
 | `LCODE_WEB` | `web` |
 | `LCODE_SANDBOX` | `sandbox` |
 | `LCODE_MEMORY` | `memory` |

lcode_cli-0.16.0/docs/hooks.md

@@ -0,0 +1,134 @@
+# Hooks and permission rules
+
+Some things should happen whatever the model does: format every edited file, never force-push,
+run the tests when a request is done. Hooks and permission rules do that without relying on the
+model to follow instructions.
+
+They go in `~/.config/lcode/config.toml` (yours, for every repository) or in a repository's
+`.lcode/settings.toml` (shared with everyone who works on it). A repository's settings are used only
+after you [approve them](commands.md#approving-a-repositorys-commands-skills-and-agents), because
+hooks run commands; lcode asks again whenever the file changes.
+
+## Permission rules
+
+Rules are checked before lcode asks for permission. An **allow** rule lets an action through
+without asking; a **deny** rule blocks it, even in `yolo` mode and even for commands that are
+otherwise read-only. Deny always wins.
+
+```toml
+[permissions]
+allow = ["bash:pytest *", "bash:npm test", "bash:ruff *", "edit:src/**", "web:docs.python.org"]
+deny = ["bash:git push --force*", "bash:git push -f*", "bash:rm -rf /*", "edit:.env", "edit:**/*.pem"]
+```
+
+| Rule | Matches |
+|---|---|
+| `bash:<pattern>` | Shell commands, with `*` and `?` wildcards. A leading `cd <folder> &&` is ignored. A deny rule matches any part of a chained command (`git add . && git push --force`); an allow rule needs the whole command, or every part of it, to be allowed |
+| `edit:<pattern>` | Files the model writes or edits, relative to the repository's root. A pattern without a `/` matches the file name anywhere (`.env`, `*.pem`); `src/**` matches everything under `src` |
+| `web:<domain>` | Pages fetched from a domain; `web:search` for searches (only asked about with `web = "ask"`) |
+| `mcp:<server>:<tool>` | An [MCP](mcp.md) server's tools, e.g. `mcp:github:list_*` |
+
+When a rule blocks something, the model is told which rule, and not to work around it.
+
+## Hooks
+
+```toml
+[[hooks]]
+event = "after_tool"
+tools = ["edit_file", "write_file"]
+paths = ["*.py"]
+command = "ruff format {path} && ruff check --fix {path}"
+```
+
+| Event | Runs | What it can do |
+|---|---|---|
+| `before_tool` | Before a tool call | Exit with code **2** to block the call; what the hook printed tells the model why |
+| `after_tool` | After a tool call | Its output goes to the model when it exits with an error, or always with `feedback = true` |
+| `after_request` | When a request is done | Its output is shown to you |
+| `session_start` | When a session starts | Its output is shown, and with `feedback = true` given to the model |
+| `notification` | When lcode waits for your answer, and when a request that took over 30 seconds is done | Show a desktop notification, ring a bell |
+
+| Key | |
+|---|---|
+| `event` | One of the events above (required) |
+| `command` | Run with `bash -c` in the working directory (required). `{path}` and `{tool}` are replaced, quoted |
+| `tools` | Only for these tools (wildcards allowed), e.g. `["edit_file", "write_file"]` or `["mcp__*"]` |
+| `paths` | Only for these files, like the `edit:` rules: `["*.py"]`, `["src/**"]` |
+| `timeout` | Seconds before the hook is stopped (default 60) |
+| `feedback` | `true` to give the hook's output to the model even when it succeeds |
+
+Each hook gets the event as JSON on its standard input (the tool, its arguments, the file's full
+path, the result for `after_tool`, the working directory), and in the environment variables
+`LCODE_EVENT`, `LCODE_TOOL` and `LCODE_PATH`. Hooks run on your machine, also with the
+[sandbox](sandbox.md) on.
+
+## Recipes
+
+**Format and lint Python files after every edit** (lint problems go back to the model):
+
+```toml
+[[hooks]]
+event = "after_tool"
+tools = ["edit_file", "write_file"]
+paths = ["*.py"]
+command = "ruff format --quiet {path} && ruff check --fix --quiet {path}"
+```
+
+**Prettier for JavaScript and TypeScript:**
+
+```toml
+[[hooks]]
+event = "after_tool"
+tools = ["edit_file", "write_file"]
+paths = ["*.ts", "*.tsx", "*.js", "*.jsx", "*.css", "*.json"]
+command = "npx --no-install prettier --write {path} > /dev/null"
+```
+
+**Never force-push.** A rule is enough:
+
+```toml
+[permissions]
+deny = ["bash:git push --force*", "bash:git push -f*", "bash:git push * --force*"]
+```
+
+or, with a hook that explains the house rule to the model:
+
+```toml
+[[hooks]]
+event = "before_tool"
+tools = ["bash"]
+command = '''
+if jq -r .arguments.command | grep -Eq 'git push.*(--force|-f)'; then
+  echo "Force-pushing isn't allowed here: push to a new branch and open a pull request instead."
+  exit 2
+fi
+'''
+```
+
+**Run the tests when a request is done:**
+
+```toml
+[[hooks]]
+event = "after_request"
+command = "pytest -q -x 2>&1 | tail -3"
+timeout = 300
+```
+
+**A desktop notification** when lcode needs you or finishes a long request:
+
+```toml
+[[hooks]]
+event = "notification"
+command = "notify-send lcode \"$(jq -r .message)\""   # macOS: osascript -e "display notification \"…\""
+```
+
+**Tell the model what branch it's on** at the start of every session:
+
+```toml
+[[hooks]]
+event = "session_start"
+command = "git status --short --branch | head -20"
+feedback = true
+```
+
+`lcode doctor` lists the hooks and rules it found, and any it couldn't read.

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/how-it-works.md

@@ -106,6 +106,7 @@ the Ollama server you configure, it only contacts the web when the model searche
 | `bench.py` | `lcode bench`: the benchmark tasks, their checks and the reports |
 | `vision.py` | Looking at images with a model that can see |
 | `subagents.py` | Subagents: agent types, running them (also in parallel), worktrees for workers |
+| `hooks.py` | Hooks on lcode's events, and allow and deny rules for permissions |
 | `repomap.py`, `codesearch.py` | The repository map, and semantic code search with an embedding model |
 | `lsp.py` | Language servers: the `lsp` tool and errors after edits |
 | `extensions.py` | Custom commands and skills, and approving a repository's own |

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/installation.md

@@ -151,6 +151,11 @@ lcode config set ollama_host http://gpu-server:11434
 Your prompts and the code the model reads are then sent to that server. Ollama has no
 authentication; only expose it on a network you trust (or through an SSH tunnel).
 
+### LM Studio, llama.cpp, vLLM or MLX instead of Ollama
+
+lcode also works with any server that has an OpenAI-compatible API: `lcode config set backend
+lmstudio` (or `llama.cpp`, `vllm`, `mlx`). See [Other model servers](servers.md).
+
 ### Windows
 
 Use [WSL2](https://learn.microsoft.com/windows/wsl/install) with Ubuntu and follow the Ubuntu

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.14.0 — local coding agent           │
+│ lcode v0.16.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

lcode_cli-0.16.0/docs/servers.md

@@ -0,0 +1,136 @@
+# Other model servers
+
+lcode is built around [Ollama](https://ollama.com), but it also works with any server that has an
+OpenAI-compatible API: [LM Studio](https://lmstudio.ai),
+[llama.cpp](https://github.com/ggml-org/llama.cpp)'s `llama-server`, [vLLM](https://docs.vllm.ai)
+and the [MLX](https://github.com/ml-explore/mlx-lm) server. Tool calls, streaming answers, reasoning
+and all of lcode's tools work the same.
+
+```bash
+lcode config set backend lmstudio      # or llama.cpp, vllm, mlx
+lcode doctor                           # checks the server, the model and its context window
+lcode
+```
+
+| `backend` | Server | Default address |
+|---|---|---|
+| `ollama` (default) | Ollama | `ollama_host`, `http://localhost:11434` |
+| `lmstudio` | LM Studio | `http://localhost:1234/v1` |
+| `llama.cpp` | llama-server | `http://localhost:8080/v1` |
+| `vllm` | vLLM | `http://localhost:8000/v1` |
+| `mlx` | `mlx_lm.server` | `http://localhost:8080/v1` |
+| `openai` | Any other OpenAI-compatible API | Set `base_url` |
+
+- **Another address:** `lcode config set base_url http://gpu-box:8000/v1`.
+- **A server that needs a key:** put it in `LCODE_API_KEY` (or `OPENAI_API_KEY`). lcode sends it as a
+  bearer token and never writes it to the config file.
+- **For one run:** `LCODE_BACKEND=llama.cpp lcode`.
+
+Your prompts and the code the model reads go to that server, so use one you run yourself or trust.
+
+## Choosing the model
+
+The `model` setting names a model the server serves. `lcode models` lists them:
+
+```text
+$ lcode models
+Models served by LM Studio at http://localhost:1234/v1
+  google/gemma-4-12b
+  qwen/qwen3.6-35b-a3b  current
+```
+
+Part of the name is enough when only one model matches (`lcode -m gemma`). A server with a single
+model, like llama-server, uses it whatever the setting says. `lcode setup` only installs models
+into Ollama: download models in the server itself.
+
+## The context window
+
+With Ollama, lcode chooses the context window and loads the model with it. Other servers load the
+model themselves, with their own window, so lcode reads its size from the server:
+
+- llama-server: the `-c` option;
+- vLLM: `--max-model-len`;
+- LM Studio: the context length the model was loaded with.
+
+lcode then summarizes the conversation before it outgrows that window. The MLX server and Ollama's
+own OpenAI endpoint don't report a size, so lcode assumes 32K; set the real size with
+`lcode config set context 64k`. A smaller value than the server's is fine (`/ctx 16k`): lcode just
+summarizes sooner.
+
+lcode's instructions and tool definitions take about 6K tokens, so give the model at least 32K.
+
+## Setting up each server
+
+### LM Studio
+
+1. Download a model that supports tool use, such as Qwen3.6 35B A3B or Gemma 4.
+2. Load it with a context length of 32K or more. LM Studio's default of 4K is too small for a
+   coding agent.
+3. Start the server: in the Developer tab, or with `lms server start`.
+4. Point lcode at it:
+
+   ```bash
+   lcode config set backend lmstudio
+   lcode models                           # the ids LM Studio serves
+   lcode config set model qwen/qwen3.6-35b-a3b
+   ```
+
+On a Mac, LM Studio's MLX models are the fastest route. Load the model before you start lcode: a
+model that LM Studio loads on request gets LM Studio's default context length.
+
+### llama.cpp (llama-server)
+
+```bash
+llama-server -m Qwen3.6-35B-A3B-Q4_K_M.gguf --alias qwen3.6-35b --jinja -c 65536 -ngl 99 --n-cpu-moe 20
+lcode config set backend llama.cpp
+```
+
+- `--jinja` is required for tool calls.
+- `-c` sets the context window, which lcode reads.
+- `--alias` gives the model a short name; otherwise its name is the file's path.
+- On a GPU too small for the whole model, `--n-cpu-moe N` (or `--cpu-moe`) keeps a mixture-of-experts
+  model's expert layers in RAM.
+
+With Docker and an NVIDIA GPU:
+
+```bash
+docker run -d --gpus all -p 127.0.0.1:8080:8080 -v ~/models:/models ghcr.io/ggml-org/llama.cpp:server-cuda \
+  -m /models/Qwen3.6-35B-A3B-Q4_K_M.gguf --alias qwen3.6-35b --jinja -c 65536 -ngl 99 --n-cpu-moe 20 \
+  --host 0.0.0.0
+```
+
+### vLLM
+
+```bash
+vllm serve Qwen/Qwen3-32B --max-model-len 32768 \
+  --enable-auto-tool-choice --tool-call-parser hermes --reasoning-parser qwen3
+lcode config set backend vllm
+```
+
+vLLM needs `--enable-auto-tool-choice` and the tool-call parser for the model's family (see vLLM's
+[tool calling](https://docs.vllm.ai/en/latest/features/tool_calling.html) page). A reasoning parser
+keeps the model's thinking out of its answers.
+
+### MLX (Apple silicon)
+
+```bash
+pip install mlx-lm
+mlx_lm.server --model mlx-community/Qwen3-30B-A3B-4bit
+lcode config set backend mlx
+lcode config set context 32k
+```
+
+## What's different from Ollama
+
+| | Ollama | Other servers |
+|---|---|---|
+| Context window | lcode chooses it, and falls back to a smaller one when the GPU runs out of memory | The server's; lcode reads it |
+| Reasoning on and off (`/think`, `--no-think`) | Yes | Yes, for models whose chat template has a switch (Qwen and others) on llama-server and vLLM |
+| Thinking shown separately | Yes | Yes. When a server sends the thinking as part of the answer, lcode moves it out |
+| Images | The model's own vision, or `vision_model` | Set `vision_model` to a model the server serves that can see images |
+| [Code search](search.md#semantic-code-search) | Any installed embedding model | Needs the server to serve an embedding model too, as LM Studio can |
+| Freeing the GPU for MCP tools that need it | Yes | No: the server decides what stays loaded |
+| `lcode bench` memory columns | Measured | Empty: the server doesn't report them |
+
+`lcode bench` works the same way with any backend, so you can compare the same model on two
+servers: `LCODE_BACKEND=llama.cpp lcode bench`.

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/docs/usage.md

@@ -147,7 +147,8 @@ Read-only commands run without asking: `ls`, `cat`, `head`, `tail`, `grep`, `rg`
 output, chain commands or run subshells. A `cd <folder> &&` in front is fine.
 
 When asked, answer ++y++ (once), ++a++ (always, for this command or for all edits, until you quit)
-or ++n++. Text after ++n++ goes to the model as instructions: `n run the tests with -x first`.
+or ++n++. For lasting answers, write [permission rules](hooks.md#permission-rules): allow lists and
+deny lists, per user or per repository; deny always wins, even in `yolo`. Text after ++n++ goes to the model as instructions: `n run the tests with -x first`.
 
 !!! warning "yolo mode"
 

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/mkdocs.yml

@@ -98,9 +98,11 @@ nav:
       - Code intelligence: lsp.md
       - Repository map and code search: search.md
       - Models & context windows: models.md
+      - Other model servers: servers.md
       - Benchmarking models: bench.md
       - MCP servers: mcp.md
       - Sandbox: sandbox.md
+      - Hooks and permission rules: hooks.md
       - Configuration: configuration.md
   - Reference:
       - How it works: how-it-works.md

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/pyproject.toml

@@ -83,6 +83,7 @@ ignore = [
 "src/lcode/repomap.py" = ["E501"]
 "src/lcode/codesearch.py" = ["E501"]
 "src/lcode/bench_backend.py" = ["E501"]
+"src/lcode/backends.py" = ["E501"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.14.0"
+__version__ = "0.16.0"

{lcode_cli-0.14.0 → lcode_cli-0.16.0}/src/lcode/agent.py

@@ -216,6 +216,9 @@ class Agent:
         self.checkpoints = Checkpoints(self.console, settings.checkpoints)
         self.mcp: McpManager | None = None  # set by the CLI when MCP servers are configured
         self.lsp = None  # an lcode.lsp.Manager, set by the CLI when language servers are installed
+        from lcode.hooks import HookSet
+
+        self.hooks = HookSet()  # set by the CLI from the settings (lcode.hooks)
         self._repo_map: tuple[Path, repomap.RepoMap, str] | None = None
         self._code_index: tuple[Path, codesearch.Index | None] | None = None
         self.sandbox = (
@@ -567,7 +570,8 @@ class Agent:
                 self.console.print(f"[dim]{self.settings.model} does not support reasoning; continuing without.[/]")
                 yield from self.chat(messages, tools, False)
                 return
-            if any(marker in error for marker in GPU_MEMORY_ERRORS):
+            # Only Ollama loads the model with lcode's settings; other servers manage their own memory.
+            if getattr(self.ollama, "kind", "ollama") == "ollama" and any(m in error for m in GPU_MEMORY_ERRORS):
                 batch = self.settings.num_batch
                 if not started and batch and batch > SAFE_NUM_BATCH:
                     # Larger batches read prompts faster but need extra VRAM that isn't always free.
@@ -722,6 +726,14 @@ class Agent:
             self._run_turn(user_text)
         finally:
             self.checkpoints.end_turn()
+            if self.hooks.hooks and self.allowed_tools is None:
+                payload = {"request": user_text[:2000], "cwd": str(self.cwd), "session": self.session_id}
+                for outcome in self.hooks.run("after_request", payload, self.cwd):
+                    style = "dim" if outcome.code == 0 else "yellow"
+                    if outcome.output or outcome.code:
+                        self.console.print(
+                            Text(f"  ⎿ after_request hook ({outcome.code}): {outcome.output[:500]}", style=style)
+                        )
 
     def sandbox_root(self) -> Path | None:
         """The folder the model is limited to while the sandbox is on (None when it's off)."""