lcode-cli 0.28.1__tar.gz → 0.29.0__tar.gz

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/CHANGELOG.md

@@ -6,6 +6,24 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.29.0] - 2026-10-13
+
+### Added
+
+- lcode runs the project's checks before calling work done. After a request that changed files, it
+  runs the tests (pytest, unittest, npm/pnpm/yarn/bun test, cargo test, go test or make test, found
+  from the project, or the command in `.lcode/settings.toml` or the `checks` setting). When they
+  fail, the model gets the output and keeps working, twice at most, and then says what still fails.
+  Checks the model already ran after its last change aren't repeated. `lcode -p --output json`
+  reports them in `checks`, and `lcode bench --checks off` compares. See
+  [Checks before done](https://nasser1941.github.io/lcode/usage/#checks-before-done).
+
+### Fixed
+
+- A tool call that Ollama couldn't read because its XML was out of order (`expected element type
+  <function> but have <parameter>`) ended the request with an error. Like other malformed calls,
+  it's now sent back to the model to make again.
+
 ## [0.28.1] - 2026-10-13
 
 ### Fixed
@@ -632,7 +650,8 @@ 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.28.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.29.0...HEAD
+[0.29.0]: https://github.com/nasser1941/lcode/compare/v0.28.1...v0.29.0
 [0.28.1]: https://github.com/nasser1941/lcode/compare/v0.28.0...v0.28.1
 [0.28.0]: https://github.com/nasser1941/lcode/compare/v0.27.0...v0.28.0
 [0.27.0]: https://github.com/nasser1941/lcode/compare/v0.26.0...v0.27.0

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.28.1
+Version: 0.29.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/

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/docs/automation.md

@@ -55,6 +55,7 @@ went: `0` success, `1` an error, `3` stopped at `--max-steps`, `4` stopped becau
 | `tool_calls` | Every tool call, with its arguments and output (the first 4,000 characters). `error` is true when the call failed or wasn't allowed |
 | `files_changed` | Files the request added (`A`), modified (`M`) or deleted (`D`), shell commands included |
 | `usage` | Model requests and tokens; `prompt_tokens` includes tokens served from the prompt cache |
+| `checks` | The [checks](usage.md#checks-before-done) that ran after the change: `command`, `exit_code` (`null` when they weren't allowed to run) and `by` (`lcode`, or `model` when the model ran them itself) |
 | `error` | What went wrong, when `status` is `error` |
 | `session_id` | Continue the conversation later with `lcode --resume <id>` |
 

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/docs/configuration.md

@@ -43,6 +43,7 @@ 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)) |
 | `notify` | `true` | A desktop [notification](usage.md#notifications) when a long request is done or waits for your answer |
 | `notify_after` | `30` | Seconds a request runs before it notifies |
+| `checks` | `auto` | Run the project's [checks](usage.md#checks-before-done) after a request changed files: `auto` (found from the project), `off`, or a command |
 | `repeat_limit` | `3` | Identical tool calls with identical results before lcode [steps in](how-it-works.md#when-the-model-repeats-itself); `0` turns it off |
 | `secret_check` | `true` | Before `git commit` and `git push`, look for passwords, keys and tokens they'd add ([details](usage.md#secrets-in-commits)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/docs/quickstart.md

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

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/docs/usage.md

@@ -113,6 +113,42 @@ reasoning is on.
 lcode refuses to edit a file the model hasn't read in the session, or one that changed on disk since
 it was read, so the model always edits the current version.
 
+## Checks before done
+
+Small models like to call work done after a syntax check. So after a request that changed files, lcode
+runs the project's checks itself before the answer is final:
+
+```text
+◆ Checking the work: python -m unittest (from test files)
+⚠ Checks fail (python -m unittest, exit code 1): the model gets the output to fix it.
+◆ Checking the work: python -m unittest (from test files)
+◆ Checks pass: python -m unittest
+```
+
+- **When they fail,** the model gets the output and keeps working, twice at most. After that its answer
+  says what still fails instead of claiming success. A failure that the change didn't cause is
+  reported, not chased, and the checks run again only if the model changes something more.
+- **When nothing could run** (no tests collected, or the test runner isn't installed), lcode says so
+  and doesn't send it to the model.
+- **When the model already ran them** after its last change and they passed, they aren't run again.
+- **Permission:** they run like any other command, so in `ask` mode the first run asks (++a++ allows
+  them for the session).
+- **Programs** using `lcode -p --output json` see the runs in the result's `checks`.
+
+**Which checks.** lcode looks at the project: pytest when the configuration mentions it (`uv run
+pytest -q` with a `uv.lock`), otherwise `python -m unittest` for `test_*.py` files. Then
+`npm test` (or pnpm, yarn, bun) when `package.json` has a test script, `cargo test`, `go test ./...`
+and `make test`. To choose the command yourself, set it for the repository in
+`.lcode/settings.toml`. That file is used once you trust the repository, like its hooks:
+
+```toml
+[checks]
+command = "uv run pytest -q && uv run ruff check ."
+```
+
+Or set it for yourself with `lcode config set checks "make check"`; `lcode config set checks off`
+turns checks off.
+
 ## Background commands
 
 Some commands keep running: a dev server, a test watcher, a build in watch mode. The model starts

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/src/lcode/__init__.py

@@ -3,7 +3,7 @@
 From a program: `from lcode import Session` (see lcode.api).
 """
 
-__version__ = "0.28.1"
+__version__ = "0.29.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/src/lcode/agent.py

@@ -27,6 +27,7 @@ from rich.text import Text
 
 from lcode import (
     catalog,
+    checks,
     codesearch,
     extensions,
     limits,
@@ -81,7 +82,13 @@ EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 REFUSED = ("Error:", "A deny rule", "The user denied", "This needs the user's permission")
 MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren't valid JSON
 # How Ollama reports a tool call it couldn't parse (Qwen3.6's calls are XML)
-MALFORMED_CALL = ("error parsing tool call", "XML syntax error")
+MALFORMED_CALL = (
+    "error parsing tool call",
+    # Go's XML decoder, for models that write calls as XML (Qwen3.6): a cut-off or misordered call
+    "XML syntax error",
+    "expected element type",
+    "closed by </",
+)
 RESULT_SHARE = 0.25  # of the context window, at most, for one tool result
 MIN_RESULT_CHARS = 8000
 READING_NOTE_TOKENS = 4000  # new input this large gets "Reading … new tokens" in the status line
@@ -114,7 +121,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 - A syntax check or an import only shows that code loads. Run what you changed the way it will be used (the script, the tests, the app) and fix what fails.
 - To fix a bug, first reproduce each problem the user reports with a test, a command or a short script, then run the same checks to show they're gone.
 - For what you can't see, like a GUI, a web page or a layout, check it without a screen where you can: `QT_QPA_PLATFORM=offscreen` for Qt, a headless browser, or a script that prints sizes and positions or renders to an image{look}. Measure instead of assuming.
-- Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.
+- Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.{checks}
 
 # Communication
 - Be concise and direct; no filler. Use GitHub-flavored markdown.
@@ -268,6 +275,7 @@ class Settings:
     secret_check: bool = True  # scan what git commit and git push would add (lcode.secretscan)
     compact_at: int = 0  # tokens: make room at this size even when the window is larger (0: only at 85%)
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
+    checks: str = "off"  # the project's checks after a change (lcode.checks): auto, off or a command
 
 
 class Agent:
@@ -324,6 +332,8 @@ class Agent:
         self.made_room_for = ""  # why the model was unloaded (the vision model, an MCP tool), for the reload line
         self.load_state = ""  # "loading" while the model loads in the background at startup (lcode.repl)
         self.autosave = False  # save the session after every step (sessions people resume; not the bench's)
+        self._check: tuple[Path, checks.Check | None] | None = None
+        self.check_results: list[dict] = []  # the checks of the last request: command, exit code, who ran them
         self.sent_chars = 0  # characters of the conversation the model had already read
         self.counted_chars: int | None = None  # characters that ctx_used covers (None: all of them)
         self.turn_status = ""  # how the last request ended: success, max_steps, loop
@@ -363,6 +373,7 @@ class Agent:
             code=self.code_prompt(),
             map=self.map_prompt(),
             look=" you look at with view_image" if self.vision_model() else "",
+            checks=self.checks_prompt(),
         )
 
     def repo_map(self) -> repomap.RepoMap | None:
@@ -812,6 +823,64 @@ class Agent:
             self.last_speed = final.get("eval_count", 0) / seconds if seconds else 0.0
         return message
 
+    def checks_prompt(self) -> str:
+        check = self.project_check()
+        if check is None:
+            return ""
+        return (
+            f"\n- When you've changed files, lcode runs the project's checks (`{check.command}`) before your answer "
+            "is final, and gives you the failures to fix. Run them yourself while you work, too."
+        )
+
+    def project_check(self) -> checks.Check | None:
+        """The project's check command, for the main agent outside plan mode and reviews (None otherwise)."""
+        if self.allowed_tools is not None or self.planning() or self.no_changes or self.settings.checks == "off":
+            return None
+        root = project_root_or_cwd(self.cwd)
+        if self._check is None or self._check[0] != root or self._check[1] is None:  # tests may appear meanwhile
+            self._check = (root, checks.find(root, self.settings.checks, self.settings.trust_project))
+        return self._check[1]
+
+    def model_ran_checks(self, command: str, result: str) -> bool:
+        """Whether a command the model ran was the project's checks, and they passed."""
+        check = self.project_check()
+        if check is None or not checks.covers(check, command) or checks.exit_code(result) != 0:
+            return False
+        self.check_results.append({"command": check.command, "exit_code": 0, "by": "model"})
+        return True
+
+    def run_check(self, check: checks.Check, round_: int) -> str | None:
+        """Run the checks after a change. Returns what to tell the model when they fail, else None."""
+        self.say(f"Checking the work: {check.command} (from {check.source})")
+        result = self.tools.run("bash", {"command": check.command, "timeout": checks.TIMEOUT})
+        code = checks.exit_code(result)
+        self.check_results.append({"command": check.command, "exit_code": code, "by": "lcode"})
+        if code is None:
+            self.say(f"The checks didn't run: {result.splitlines()[0][:200]}", warning=True)
+            return None
+        if code == 0:
+            self.say(f"Checks pass: {check.command}")
+            return None
+        if checks.no_tests(check, result):
+            self.say(f"The checks found no tests to run ({check.command}).")
+            return None
+        if checks.missing(check, result):
+            self.say(
+                f"The checks couldn't run ({check.command}): {result.splitlines()[0][:160]}. Install what they need, "
+                'or set the command: lcode config set checks "…" (or checks off).',
+                warning=True,
+            )
+            return None
+        if round_ >= checks.MAX_ROUNDS:
+            self.say(
+                f"Checks still fail ({check.command}, exit code {code}): the model will say what's left.", warning=True
+            )
+        else:
+            self.say(
+                f"Checks fail ({check.command}, exit code {code}): the model gets the output to fix it.", warning=True
+            )
+        return checks.failure_note(check, result, round_)
+
     def before_request(self, progress: Progress) -> residency.LoadWatch | None:
         """Set the status line for what comes before the first token: loading the model if it isn't in memory
         (watched until it is), then reading the prompt. Returns the watch while the model loads."""
@@ -948,6 +1017,9 @@ class Agent:
         note = planning.NOTE if self.planning() and self.allowed_tools is None else ""
         self.messages.append({"role": "user", "content": self.expand_mentions(user_text) + note})
         self.repeats.reset()
+        self.check_results = []
+        changed = verified = False  # files changed in this request; the checks passed since
+        check_rounds = 0
         malformed = 0
         looping = ""  # the call the model kept repeating, when lcode stopped the request for it
         for step in range(self.max_steps):
@@ -983,6 +1055,8 @@ class Agent:
                     reason = str(e).rsplit("err=", 1)[-1].strip()
                 elif "XML syntax error" in str(e):
                     reason = str(e).split("XML syntax error", 1)[1].strip(" :") or "invalid XML"
+                elif "expected element type" in str(e) or "closed by </" in str(e):
+                    reason = str(e).split("Ollama error:", 1)[-1].strip() or "invalid XML"
                 else:
                     reason = "invalid JSON"
                 self.console.print("[yellow]The model wrote a malformed tool call; asking it to try again.[/]")
@@ -996,6 +1070,15 @@ class Agent:
                 )
                 continue
             if not calls:
+                check = self.project_check() if changed and not verified else None
+                if check is not None and check_rounds < checks.MAX_ROUNDS:
+                    check_rounds += 1
+                    feedback = self.run_check(check, check_rounds)
+                    if feedback:
+                        self.messages.append({"role": "user", "content": feedback})
+                        changed = False  # run them again only if the model changes something more
+                        continue
+                    verified = True
                 break
             done: dict[int, str] = {}  # results of subagents that ran together
             together = [
@@ -1051,6 +1134,10 @@ class Agent:
                     )
                     if verdict.stop:
                         looping = self.describe_call(name, args)
+                if name in ("edit_file", "write_file") and not result.startswith(REFUSED):
+                    changed, verified = True, False
+                elif name == "bash" and changed and self.model_ran_checks(str(args.get("command", "")), result):
+                    verified = True  # the model ran the checks itself, after its last change
                 tool_msg = {"role": "tool", "tool_name": name, "content": result}
                 if call.get("id"):
                     tool_msg["tool_call_id"] = call["id"]

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/src/lcode/api.py

@@ -76,6 +76,7 @@ class Result:
     tool_calls: list[dict] = field(default_factory=list)  # {"id", "name", "arguments", "error", "output"}
     files_changed: list[dict] = field(default_factory=list)  # {"status": "A" | "M" | "D", "path"}
     usage: dict = field(default_factory=dict)  # requests, prompt_tokens, output_tokens
+    checks: list[dict] = field(default_factory=list)  # {"command", "exit_code", "by": "lcode" | "model"}
     seconds: float = 0.0
     error: str = ""
 
@@ -196,6 +197,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         notify_after=cfg["notify_after"],
         secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
+        checks=cfg["checks"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -303,6 +305,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         tool_calls=list(calls.values()),
         files_changed=files,
         usage=usage,
+        checks=list(agent.check_results),
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

lcode_cli-0.29.0/src/lcode/checks.py

@@ -0,0 +1,160 @@
+"""Run the project's checks before calling work done.
+
+Small models call work done after a syntax check, and telling them to verify isn't enough. So after a request
+that changed files, lcode runs the project's check command itself (its tests, or a linter) before the answer
+counts as final. When it fails, the output goes back to the model, which keeps working, at most `MAX_ROUNDS`
+times; then the answer says plainly that the checks still fail.
+
+The command is, in order: the repository's `.lcode/settings.toml` (`[checks] command = "…"`, used once the
+repository is trusted, like its hooks), the user's `checks` setting, or what the project looks like: pytest,
+unittest, npm test, cargo test, go test, make test. `checks = "off"` turns it off.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+
+MAX_ROUNDS = 2  # times the model gets failing checks back before lcode stops asking
+TIMEOUT = 600  # seconds a check may run
+OUTPUT_TAIL = 6000  # characters of a failing check's output the model gets back
+EXIT = re.compile(r"\[exit code: (-?\d+)\]\s*$")
+
+
+@dataclass
+class Check:
+    command: str
+    source: str  # where it comes from, for the user: "pyproject.toml", "your configuration"…
+
+
+def find(root: Path, setting: str, trusted: bool) -> Check | None:
+    """The project's check command, or None when there's none or checks are off."""
+    setting = (setting or "auto").strip()
+    if setting == "off":
+        return None
+    if trusted:
+        from lcode.hooks import HookError, read_toml
+
+        try:
+            data = read_toml(root / ".lcode" / "settings.toml")
+        except HookError:
+            data = {}
+        command = str((data.get("checks") or {}).get("command") or "").strip()
+        if command:
+            return Check(command, ".lcode/settings.toml")
+    if setting != "auto":
+        return Check(setting, "your configuration (checks)")
+    return detect(root)
+
+
+def python() -> str:
+    return "python" if shutil.which("python") else "python3"
+
+
+def text(path: Path) -> str:
+    try:
+        return path.read_text(errors="replace") if path.is_file() else ""
+    except OSError:
+        return ""
+
+
+def python_tests(root: Path) -> bool:
+    """Whether the project has Python test files (a few levels deep, outside environments and caches)."""
+    from lcode.tools import IGNORE_DIRS
+
+    def walk(folder: Path, depth: int) -> bool:
+        try:
+            entries = list(folder.iterdir())
+        except OSError:
+            return False
+        if any(e.is_file() and re.fullmatch(r"test_.*\.py|.*_test\.py", e.name) for e in entries):
+            return True
+        return depth > 0 and any(
+            walk(e, depth - 1)
+            for e in entries
+            if e.is_dir() and e.name not in IGNORE_DIRS and not e.name.startswith(".")
+        )
+
+    return walk(root, 3)
+
+
+def detect(root: Path) -> Check | None:
+    """A check command from what the project looks like. Python checks need test files: pytest configured in a
+    project without tests "fails" with nothing to run."""
+    if python_tests(root):
+        configs = text(root / "pyproject.toml") + text(root / "setup.cfg") + text(root / "tox.ini")
+        if "pytest" in configs or any((root / name).is_file() for name in ("pytest.ini", "conftest.py")):
+            runner = "uv run pytest -q" if (root / "uv.lock").is_file() else f"{python()} -m pytest -q"
+            return Check(runner, "pytest in the project's configuration")
+        if list(root.glob("test_*.py")) or list(root.glob("*_test.py")):
+            return Check(f"{python()} -m unittest", "test files")
+        if (root / "tests").is_dir():
+            return Check(f"{python()} -m unittest discover -s tests -t .", "tests/")
+    package = text(root / "package.json")
+    if package:
+        try:
+            test = (json.loads(package).get("scripts") or {}).get("test") or ""
+        except ValueError:
+            test = ""
+        if test and "no test specified" not in test:
+            for lock, tool in (("pnpm-lock.yaml", "pnpm"), ("yarn.lock", "yarn"), ("bun.lockb", "bun")):
+                if (root / lock).is_file():
+                    return Check(f"{tool} test", "package.json")
+            return Check("npm test", "package.json")
+    if (root / "Cargo.toml").is_file():
+        return Check("cargo test", "Cargo.toml")
+    if (root / "go.mod").is_file():
+        return Check("go test ./...", "go.mod")
+    if re.search(r"^test:", text(root / "Makefile"), re.M):
+        return Check("make test", "Makefile")
+    return None
+
+
+NO_TESTS = 5  # pytest's and unittest's exit code when no test ran: not a failure
+
+
+def no_tests(check: Check, result: str) -> bool:
+    return exit_code(result) == NO_TESTS and bool(re.search(r"pytest|unittest", check.command))
+
+
+def exit_code(result: str) -> int | None:
+    """The exit code at the end of a bash tool result (None: it didn't run, e.g. not allowed)."""
+    found = EXIT.search(result)
+    return int(found.group(1)) if found else None
+
+
+def covers(check: Check, command: str) -> bool:
+    """Whether a command the model ran is this check (`cd x && uv run pytest -q 2>&1 | tail` counts)."""
+    return " ".join(check.command.split()) in " ".join(command.split())
+
+
+def failure_note(check: Check, result: str, round_: int) -> str:
+    output = result if len(result) <= OUTPUT_TAIL else "…" + result[-OUTPUT_TAIL:]
+    last = round_ >= MAX_ROUNDS
+    return (
+        f"[lcode] Your changes are done, but the project's checks fail: `{check.command}` "
+        f"(exit code {exit_code(result)}).\n\n{output}\n\n"
+        + (
+            "This was the last check lcode runs for this request. Don't change anything more: tell the user what "
+            "still fails and why."
+            if last
+            else "Fix what your changes broke, then finish. If a failure isn't caused by your changes (it failed "
+            "before), don't chase it: say so in your answer."
+        )
+    )
+
+
+# The check command itself is missing (not the code under test): nothing the model can fix.
+MISSING = re.compile(r"No module named '?pytest'?\s*$|command not found|^\S+: not found$", re.I | re.M)
+
+
+def missing(check: Check, result: str) -> bool:
+    """Whether the check couldn't run at all: its program isn't installed."""
+    code = exit_code(result)
+    if code == 127:
+        return True
+    head = result.splitlines()[:5]  # a missing program says so first; test failures look different
+    return code not in (0, None) and any(MISSING.search(line) for line in head)

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/src/lcode/cli.py

@@ -580,6 +580,7 @@ def cmd_bench(args) -> None:
             checkpoints=False,
             prune=not args.no_prune,
             compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
+            checks=cfg["checks"] if args.checks is None else args.checks,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -774,6 +775,11 @@ def build_subparsers() -> dict[str, argparse.ArgumentParser]:
     p.add_argument("--repo-map", action="store_true", help="give the model the repository map (off by default)")
     p.add_argument("--code-search", action="store_true", help="index each task's folder and offer semantic code search")
     p.add_argument("--no-prune", action="store_true", help="don't remove old tool output (to compare, with --session)")
+    p.add_argument(
+        "--checks",
+        metavar="auto|off|COMMAND",
+        help="run each task's checks before it counts as done (default: the checks setting)",
+    )
     p.add_argument(
         "--compact-at",
         type=compact_tokens,

{lcode_cli-0.28.1 → lcode_cli-0.29.0}/src/lcode/config.py

@@ -59,6 +59,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "subagents": (True, bool, "let the model hand tasks to subagents that have their own context"),
     "notify": (True, bool, "desktop notification when a long request is done or waits for you"),
     "notify_after": (30, int, "seconds a request runs before it notifies (with notify on)"),
+    "checks": ("auto", str, "run the project's checks before calling work done: auto | off | a command"),
     "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),