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

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

@@ -6,6 +6,57 @@ 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
+
+Found by testing lcode's tools on real files and commands (#118):
+
+- Some commands that change things ran without asking, because they were taken for read-only:
+  `sort -o`, `uniq in out`, `tree -o`, `git branch -D` and other branch changes, `git remote
+  add/remove`, `git log/diff --output`, `rg --pre` (which runs a program), `find -fls`, `date -s`,
+  and `nvidia-smi` settings. Arguments are now checked. `2>&1` and `>/dev/null` no longer make a
+  read-only command ask.
+- "Always allow" for a command also covered chains that started with it: allowing `npm test` let
+  `npm test && rm -rf build` run without asking. Now a chain needs its own "always".
+- A JSON tool call that the model only showed as an example in its answer was run. Text is now
+  taken as a call only when the whole message is one.
+- A change you made to a file while lcode asked to edit it was overwritten. lcode now notices and
+  doesn't apply the edit, and the model redoes it on the current content.
+- `replace_all: "false"`, and other values sent as text, were taken as true. They now get the
+  type the tool declares.
+- The shell timeout wasn't enforced while a command kept printing, so a watcher started without
+  `background` hung the request. Long output is no longer held in memory either: 400 MB of output
+  used to cost 2.5 GB, and now it goes to a file, keeping its start, end and error lines.
+- One tool result could overflow the context window: `read_file` returned up to ~40K tokens,
+  however small the window, and compaction only looked at the previous request. A result now takes
+  at most a quarter of the window (`read_file` says where to read on), and lcode makes room based on
+  the size of the next request.
+- Sessions were saved only when a request ended, so a crash lost the whole request. They're now
+  saved after every step, and atomically, so a crash while writing can't corrupt them.
+- Editing a file with Windows line endings turned the whole file to Unix line endings, and editing a
+  file that isn't UTF-8 (Windows-1252 or Latin-1) replaced every accented letter in it with `�`,
+  not only in the edited line. Files now keep their encoding, line endings and byte order mark. A
+  character the encoding can't hold is refused instead of written wrong.
+
 ## [0.28.0] - 2026-10-13
 
 ### Added
@@ -599,7 +650,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.28.0...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
 [0.26.0]: https://github.com/nasser1941/lcode/compare/v0.25.0...v0.26.0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.28.0
+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.0 → 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.0 → 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.0 → lcode_cli-0.29.0}/docs/quickstart.md

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

{lcode_cli-0.28.0 → 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
@@ -224,11 +260,14 @@ image support off with `lcode config set vision_model off`.
 `--yolo` start in one.
 
 Read-only commands run without asking: `ls`, `cat`, `head`, `tail`, `grep`, `rg`, `find`, `tree`,
-`wc`, `diff`, `git status/log/diff/show/branch/blame` and similar, as long as they don't redirect
-output, chain commands or run subshells. A `cd <folder> &&` in front is fine.
+`wc`, `diff`, `git status/log/diff/show/branch/blame` and similar. Their arguments count too:
+`sort -o file`, `git branch -D`, `git log --output=file`, `rg --pre` or `find -delete` change
+things, so they ask. Pipes between read-only commands are fine, and so are `cd <folder> &&` in front
+and `2>&1` or `>/dev/null`; anything else (`&&`, `;`, redirecting to a file, `$(…)`) asks.
 
 When asked, answer ++y++ (once), ++a++ (always, for this command or for all edits, until you quit)
-or ++n++. For lasting answers, write [permission rules](hooks.md#permission-rules): allow lists and
+or ++n++. "Always" covers the same program, or for a chain the same programs in the same order:
+allowing `npm test` doesn't allow `npm test && rm -rf build`. 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.28.0 → 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.0"
+__version__ = "0.29.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

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

@@ -6,6 +6,7 @@ import base64
 import contextlib
 import datetime as dt
 import json
+import os
 import platform
 import re
 import shutil
@@ -26,6 +27,7 @@ from rich.text import Text
 
 from lcode import (
     catalog,
+    checks,
     codesearch,
     extensions,
     limits,
@@ -80,7 +82,15 @@ 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
 AUTO_COMPACT_RATIO = 0.85  # summarize the history when the context is this full
 PRUNED_ENOUGH = 0.6  # after pruning old tool output, summarize only if the context is still this full
@@ -111,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.
@@ -265,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:
@@ -320,7 +331,11 @@ class Agent:
         self.hardware = None  # an lcode.hardware.Hardware, set by the CLI: for what fits on the GPU
         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
         self.repeats = Repeats(settings.repeat_limit)  # notices when the model repeats itself
         self.response = None  # the streaming response, so another thread can abort it
@@ -358,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:
@@ -576,6 +592,7 @@ class Agent:
         self.tools.read_mtimes.clear()
         self.reflected = len(self.messages)
         self.ctx_used = len(self.messages[0]["content"]) // 3
+        self.counted_chars = None
 
     def session_file(self) -> Path:
         return sessions.sessions_dir() / f"{self.session_id}.json"
@@ -597,7 +614,10 @@ class Agent:
             "messages": self.messages,
             "checkpoints": self.checkpoints.to_json(),
         }
-        f.write_text(json.dumps(data))
+        # Written next to it and then renamed: a crash halfway leaves the previous version, not a broken file.
+        partial = f.with_name(f".{f.name}.partial")
+        partial.write_text(json.dumps(data))
+        os.replace(partial, f)
 
     def new_session(self) -> None:
         self.reset()
@@ -634,6 +654,7 @@ class Agent:
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
         self.reflected = len(self.messages)  # checked for notes to remember when that session ended
         self.ctx_used = sum(len(json.dumps(m)) for m in self.messages) // 3
+        self.counted_chars = None
         return note
 
     def load_latest(self) -> bool:
@@ -797,11 +818,69 @@ class Agent:
             self.usage["output_tokens"] += final.get("eval_count", 0)
             self.usage["output_ns"] += final.get("eval_duration", 0)
             self.ctx_used = final.get("prompt_eval_count", 0) + final.get("eval_count", 0)
-            self.sent_chars = conversation_chars(self.messages)
+            self.sent_chars = self.counted_chars = conversation_chars(self.messages)
             seconds = final.get("eval_duration", 0) / 1e9
             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."""
@@ -938,11 +1017,16 @@ 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):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
+            if step and self.autosave:
+                self.save()  # a crash or a closed terminal loses at most this step
             self.maybe_compact()
             try:
                 reply = self.assistant_step()
@@ -971,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.[/]")
@@ -984,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 = [
@@ -1027,6 +1122,9 @@ class Agent:
                     self.console.print(Text(f"  {result[:300]}", style="red"))
                 elif name in ("read_file", "grep", "glob", "list_dir"):
                     self.console.print(Text(f"  ⎿ {result.count(chr(10)) + 1} line(s)", style="dim"))
+                budget = self.result_budget()
+                if len(result) > budget and name not in ("agent", "skill"):
+                    result = context_tools.shorten(result, budget, f"{name} result")
                 verdict = self.repeats.check(name, args, result)
                 if verdict.note:
                     result += verdict.note
@@ -1036,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"]
@@ -1161,8 +1263,21 @@ class Agent:
             limit = min(limit, self.settings.compact_at)
         return limit
 
+    def next_request_tokens(self) -> int:
+        """The size of the next request: what the model last counted, plus what was added since (tool output,
+        attachments). Deciding on the last count alone let one large tool result overflow the window."""
+        if self.counted_chars is None:
+            return self.ctx_used
+        return self.ctx_used + max(0, conversation_chars(self.messages) - self.counted_chars) // 3
+
+    def result_budget(self) -> int:
+        """Characters one tool result may take: a share of the window, so one large result can't fill it."""
+        return max(MIN_RESULT_CHARS, int(self.settings.context * 3 * RESULT_SHARE))
+
     def maybe_compact(self) -> None:
         limit = self.compact_limit()
+        if self.next_request_tokens() > limit:
+            self.ctx_used, self.counted_chars = self.next_request_tokens(), None
         if self.ctx_used <= limit:
             return
         enough = int(limit * PRUNED_ENOUGH / AUTO_COMPACT_RATIO)  # after pruning, a summary isn't needed below this
@@ -1231,6 +1346,7 @@ class Agent:
             )
             self.skills_loaded.clear()
         self.ctx_used = sum(len(m["content"]) for m in self.messages) // 3
+        self.counted_chars = None
         self.summarized_size = self.ctx_used
         self.sent_chars = 0
         self.reflected = len(self.messages)

{lcode_cli-0.28.0 → 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,10 +197,12 @@ 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)
     agent.hardware = hw
+    agent.autosave = True
     agent.interactive = options.interactive
     if options.max_steps:
         agent.max_steps = options.max_steps
@@ -302,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.0 → 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.0 → 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%)"),