lcode-cli 0.31.0__tar.gz → 0.33.0__tar.gz

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/CHANGELOG.md

@@ -6,6 +6,35 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.33.0] - 2026-10-14
+
+### Added
+
+- Steer while it works. Type while a request runs and press Enter: the line goes to the model at
+  its next step, as a note from you, without interrupting anything. The spinner shows what you're
+  typing and the notes waiting. Esc pauses after the current step, so you can look, then go on with
+  or without a note. Notes count as your requests for summaries and the review, and anything that
+  never reached the model goes back into the prompt. A command that runs for a while now shows a
+  spinner with its elapsed time. See
+  [Steer while it works](https://nasser1941.github.io/lcode/usage/#steer-while-it-works).
+
+### Fixed
+
+- "Where you left off" (`lcode -c`) and session titles showed lcode's own messages to the model,
+  such as a failed check, as if you had written them. They show your last request now.
+
+## [0.32.0] - 2026-10-14
+
+### Added
+
+- A review before the answer. After a request that changed files, the model checks its change
+  against your request, from the diff and its own answer, and real problems (part of the request
+  not done, an untested claim, a leftover debug print) go back to it once. One line says what the
+  review found. It's off by default: measured with qwen3.6-35b on a 12 GB laptop, it made requests
+  73% slower for one real catch. Turn it on with `lcode config set review auto`. `lcode -p --output
+  json` reports it in `review`, and `lcode bench --review` compares. See
+  [A review before the answer](https://nasser1941.github.io/lcode/usage/#a-review-before-the-answer).
+
 ## [0.31.0] - 2026-10-14
 
 ### Added
@@ -679,7 +708,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.31.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.33.0...HEAD
+[0.33.0]: https://github.com/nasser1941/lcode/compare/v0.32.0...v0.33.0
+[0.32.0]: https://github.com/nasser1941/lcode/compare/v0.31.0...v0.32.0
 [0.31.0]: https://github.com/nasser1941/lcode/compare/v0.30.0...v0.31.0
 [0.30.0]: https://github.com/nasser1941/lcode/compare/v0.29.0...v0.30.0
 [0.29.0]: https://github.com/nasser1941/lcode/compare/v0.28.1...v0.29.0

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.31.0
+Version: 0.33.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.31.0 → lcode_cli-0.33.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 |
+| `review` | What the [review](usage.md#a-review-before-the-answer) sent back to the model (`[]` when it found nothing; `null` when no review ran) |
 | `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.31.0 → lcode_cli-0.33.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 |
+| `review` | `off` | Before the answer, [review a change](usage.md#a-review-before-the-answer) against the request and send problems back to the model: `auto` or `off` |
 | `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)) |

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/docs/quickstart.md

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

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/docs/usage.md

@@ -44,6 +44,8 @@ lcode update [--check]       # update lcode, and Ollama when it runs in Docker (
 | ++enter++ | Send |
 | ++esc++ ++enter++ or a trailing `\` | New line |
 | ++ctrl+c++ | Interrupt the model or a running command |
+| Typing while it works | A note for the model, read at its next step ([Steer while it works](#steer-while-it-works)) |
+| ++esc++ while it works | Pause after the current step |
 | ++ctrl+d++ | Quit |
 | ++shift+tab++ | Cycle permission mode: ask → plan → auto-edit → yolo |
 | ++tab++ | Complete slash commands and `@` paths |
@@ -179,6 +181,32 @@ 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.
 
+## A review before the answer
+
+Models claim more than they did: half of a two-part request done, "it works now" without having
+checked, a debug print left behind. So after a request that changed files (and after the
+[checks](#checks-before-done)), lcode asks the model to step back and review its change against your
+request. It's told to judge only from what you asked, the diff, and its own answer:
+
+```text
+◆ Review: the change does what was asked.
+⚠ Review: 1 point(s) sent back to the model. First: README.md isn't changed, though …
+```
+
+Problems it can point to go back to the model once; it fixes them, or says why a point is wrong.
+`lcode -p --output json` reports what the review found in `review`.
+
+**It's off by default,** because it's an extra model answer after every change. On the 12 GB laptop
+with qwen3.6-35b, the 8 `lcode bench` tasks took 416 s with the review against 240 s without
+(8/8 against 7/8, within run-to-run noise). It found a real gap in one run of `runtime-bug` ("it can't
+be made smaller" left undone), which the model then argued away. Without reasoning, the review was
+no faster and missed that gap every time, so it reasons like the model does. Turn it on with
+`lcode config set review auto` when a stronger or faster model makes the extra look worth it.
+
+The review is asked on top of the conversation rather than in a fresh one. The model server keeps
+the processed conversation cached, and a separate review would push it out, so the next request
+would have to read the whole conversation again. On a small GPU that's tens of seconds.
+
 ## Background commands
 
 Some commands keep running: a dev server, a test watcher, a build in watch mode. The model starts
@@ -205,9 +233,10 @@ Much of the waiting with a local model isn't the model thinking: it's loading th
 a long conversation before the first word. lcode says which, in the status line under a request:
 
 ```text
-⠋ Loading qwen3.6-35b into memory… (0 tokens, 9s · Ctrl+C to stop)
-⠋ Reading the conversation (18K tokens)… (0 tokens, 21s · Ctrl+C to stop)
-⠋ Thinking… (312 tokens, 27s · Ctrl+C to stop)
+⠋ Loading qwen3.6-35b into memory… (0 tokens, 9s · type a note · Esc pauses · Ctrl+C stops)
+⠋ Reading the conversation (18K tokens)… (0 tokens, 21s · type a note · Esc pauses · Ctrl+C stops)
+⠋ Thinking… (312 tokens, 27s · type a note · Esc pauses · Ctrl+C stops)
+⠋ Running the command… (48s · type a note · Esc pauses · Ctrl+C stops)
 ```
 
 It prints a line only when something worth knowing happens, and nothing while the model simply
@@ -226,6 +255,42 @@ While the model loads in the background at startup, the status bar says
 part of them in system RAM. Dense ones slow down a lot, to a few tokens a second, which is why they
 get the warning.
 
+## Steer while it works
+
+A request can take minutes with a local model. You don't have to stop it to change course: type
+while it works, and press ++enter++. The line goes to the model at its next step, after the step it's
+on finishes, as a note from you. Nothing is interrupted or thrown away.
+
+```text
+● edit_file(tally.py)
+  ✓ Edited tally.py
+✎ Note for the model: also add a --min-count N option that skips rare words
+```
+
+What you type shows under the spinner, since the terminal doesn't echo it while lcode works:
+
+```text
+⠋ Thinking… (212 tokens, 14s · type a note · Esc pauses · Ctrl+C stops)
+  ✎ also add a --min-count N opt▏  Enter adds it as a note
+```
+
+- A note typed while the model writes its final answer still counts: the model reads it before the
+  request ends.
+- Press ++esc++ to pause after the current step, to look at what it did. Then press ++enter++ to go
+  on, type a note to go on with it, or press ++ctrl+c++ to stop the request. Press ++esc++ again
+  before the step ends if you change your mind.
+- Notes count as your requests: they're kept when old messages are
+  [summarized](how-it-works.md#context-management), and the [review](#a-review-before-the-answer)
+  checks the change against them too.
+- When lcode asks you something, such as a permission, the keyboard is yours again for the answer.
+  Keys you typed just before the question appeared are dropped, so a note you were finishing can't
+  answer it by accident.
+- What never reached the model, such as a note typed as the request ended or after ++ctrl+c++, is
+  put back in the prompt.
+
+Steering works in the interactive session on macOS and Linux. `lcode -p` and the editor
+integration don't read the keyboard during a request.
+
 ## Notifications
 
 Local models take a while, so you'll often switch to something else during a request. lcode shows

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/pyproject.toml

@@ -78,6 +78,7 @@ ignore = [
 "src/lcode/memory.py" = ["E501"]
 "src/lcode/subagents.py" = ["E501"]
 "src/lcode/planning.py" = ["E501"]
+"src/lcode/review.py" = ["E501"] # the review prompt is prose
 "src/lcode/extensions.py" = ["E501"]
 "src/lcode/context.py" = ["E501"]
 "src/lcode/lsp.py" = ["E501"]

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/__init__.py

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

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/agent.py

@@ -35,6 +35,7 @@ from lcode import (
     planning,
     repomap,
     residency,
+    review,
     sessions,
     subagents,
     vision,
@@ -51,6 +52,7 @@ from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
 from lcode.repeats import Repeats
 from lcode.sandbox import Sandbox, SandboxError, project_root
+from lcode.steer import NOTE_INTRO, Steering
 from lcode.tools import (
     LSP_SCHEMA,
     MEMORY_SCHEMA,
@@ -223,10 +225,12 @@ class Progress:
     arrives, for example while the model writes a long file into a tool call.
     """
 
-    def __init__(self, phase: str = "Thinking") -> None:
+    def __init__(self, phase: str = "Thinking", steering: Steering | None = None, tokens: bool = True) -> None:
         self.started = self.last_chunk = time.time()
         self.phase = phase
         self.chars = 0
+        self.steering = steering  # the note being typed and the notes waiting, shown on a second line
+        self.tokens = tokens  # False for a command running: no tokens to count
 
     def update(self, phase: str, text: str) -> None:
         self.phase, self.chars, self.last_chunk = phase, self.chars + len(text), time.time()
@@ -239,9 +243,11 @@ class Progress:
         now = time.time()
         streaming = self.phase in ("Thinking", "Writing")  # loading and reading say what they are throughout
         phase = self.phase if now - self.last_chunk < 3 or not streaming else "Working"
-        return Text.from_markup(
-            f"[cyan]{phase}…[/] [dim]({self.chars // 4} tokens, {now - self.started:.0f}s · Ctrl+C to stop)[/]"
-        )
+        tokens = f"{self.chars // 4} tokens, " if self.tokens else ""
+        keys = "Ctrl+C to stop" if self.steering is None else "type a note · Esc pauses · Ctrl+C stops"
+        line = Text.from_markup(f"[cyan]{phase}…[/] [dim]({tokens}{now - self.started:.0f}s · {keys})[/]")
+        below = self.steering.status() if self.steering is not None else None
+        return line if below is None else Text("\n").join([line, below])
 
 
 @dataclass
@@ -276,6 +282,7 @@ class Settings:
     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
+    review: str = "off"  # check a change against the request before the answer (lcode.review): auto or off
 
 
 class Agent:
@@ -319,6 +326,9 @@ class Agent:
         self.read_only = False  # only read-only shell commands
         self.no_changes = ""  # set during a review: why nothing may change (read-only tools only)
         self.cancel: threading.Event | None = None  # set from another thread to stop
+        self.steering: Steering | None = None  # notes typed and pauses asked for during a request (lcode.repl)
+        self.turn_requests: list[str] = []  # the request, then the notes added to it while it ran
+        self.unsent = ""  # typed during the last request but never sent to the model: back in the prompt (lcode.repl)
         self.on_tool = None  # called with (name, arguments) before each tool runs
         self.jobs = Jobs()  # background commands (shared with subagents)
         self.turn_started = 0.0  # when the running request started (time.monotonic)
@@ -334,6 +344,7 @@ class Agent:
         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.review_results: list[str] | None = None  # what the last request's review found (None: no review)
         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
@@ -746,7 +757,7 @@ class Agent:
         """Stream one model response, rendering thinking/content live. Returns the assistant message."""
         content, thinking, tool_calls, final = "", "", [], {}
         md = MarkdownStreamer(self.console)
-        progress = Progress()
+        progress = Progress(steering=self.steering)
         watch = self.before_request(progress)
         status = None
         printed_thinking = False
@@ -831,6 +842,43 @@ class Agent:
             self.last_speed = final.get("eval_count", 0) / seconds if seconds else 0.0
         return message
 
+    def reviewing(self) -> bool:
+        return (
+            self.settings.review != "off" and self.allowed_tools is None and not self.planning() and not self.no_changes
+        )
+
+    def self_review(self, answer: str) -> list[str]:
+        """Check the request's change against the request before the answer counts; the problems found."""
+        budget = int(self.settings.context * 3 * 0.25)
+        diff, changed = review.diff_of(self.tools.before, self.current_text, budget)
+        if changed < review.MIN_CHANGED_LINES:
+            return []
+        request = self.turn_requests[0] if self.turn_requests else ""
+        if len(self.turn_requests) > 1:
+            added = "\n".join(f"- {note}" for note in self.turn_requests[1:])
+            request += f"\n\nWhat the user added while you worked:\n{added}"
+        try:
+            with self.console.status("Reviewing the change against your request…", spinner="dots"):
+                problems = review.run(self, request, answer, diff)
+        except OllamaError as e:
+            self.say(f"The review didn't run: {e}", warning=True)
+            return []
+        self.review_results = problems
+        if problems:
+            self.say(
+                f"Review: {len(problems)} point(s) sent back to the model. First: {problems[0][:160]}", warning=True
+            )
+        else:
+            self.say("Review: the change does what was asked.")
+        return problems
+
+    def current_text(self, path: str) -> str | None:
+        p = self.tools.resolve(path)
+        try:
+            return self.tools.read_text(p) if p.is_file() else None
+        except OSError:
+            return None
+
     def checks_prompt(self) -> str:
         check = self.project_check()
         if check is None:
@@ -1024,8 +1072,12 @@ class Agent:
         self.turn_status = "running"
         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.turn_requests = [user_text.strip()]
         self.repeats.reset()
         self.check_results = []
+        self.review_results = None
+        self.tools.before = {}
+        reviewed = False
         changed = verified = False  # files changed in this request; the checks passed since
         check_rounds = 0
         malformed = 0
@@ -1033,6 +1085,8 @@ class Agent:
         for step in range(self.max_steps):
             if self.cancel is not None and self.cancel.is_set():
                 raise KeyboardInterrupt
+            if step and self.steering is not None:
+                self.steer()
             if step and self.autosave:
                 self.save()  # a crash or a closed terminal loses at most this step
             self.maybe_compact()
@@ -1078,6 +1132,8 @@ class Agent:
                 )
                 continue
             if not calls:
+                if self.steering is not None and self.steering.waiting():
+                    continue  # the user added a note while the model wrote its answer: it reads the note first
                 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
@@ -1087,6 +1143,12 @@ class Agent:
                         changed = False  # run them again only if the model changes something more
                         continue
                     verified = True
+                if not reviewed and self.tools.before and self.reviewing():
+                    reviewed = True
+                    problems = self.self_review(reply.get("content") or "")
+                    if problems:
+                        self.messages.append({"role": "user", "content": review.feedback(problems)})
+                        continue
                 break
             done: dict[int, str] = {}  # results of subagents that ran together
             together = [
@@ -1187,6 +1249,34 @@ class Agent:
         self.turn_status = "success"
         self.print_stats()
 
+    def steer(self) -> None:
+        """Between two steps: pause if the user pressed Esc, then hand the model the notes typed meanwhile."""
+        steering = self.steering
+        if steering is None:
+            return
+        if steering.take_pause():
+            self.console.print(
+                Text(
+                    "⏸ Paused. Press Enter to go on, type a note to go on with it, or press Ctrl+C to stop the request.",
+                    style="yellow",
+                )
+            )
+            note = steering.ask("  ⏸ ").strip()
+            if note:
+                steering.add(note)
+        notes = steering.take()
+        if not notes:
+            return
+        self.turn_requests += notes
+        self.messages.append({"role": "user", "content": "\n\n".join(notes) + "\n\n" + NOTE_INTRO})
+        for note in notes:
+            shown = note if len(note) <= 200 else note[:200] + "…"
+            self.console.print(Text(f"✎ Note for the model: {shown}", style="cyan"))
+
+    def activity(self, phase: str):
+        """A spinner with the elapsed time while something runs (a command), with the note being typed under it."""
+        return self.console.status(Progress(phase, self.steering, tokens=False), spinner="dots")
+
     def print_stats(self) -> None:
         pct = 100 * self.ctx_used / self.settings.context
         self.console.print(

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/api.py

@@ -77,6 +77,7 @@ class Result:
     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"}
+    review: list[str] | None = None  # problems the review sent back ([] when it found none; None: no review)
     seconds: float = 0.0
     error: str = ""
 
@@ -198,6 +199,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
         checks=cfg["checks"],
+        review=cfg["review"],
         compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
@@ -306,6 +308,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
         files_changed=files,
         usage=usage,
         checks=list(agent.check_results),
+        review=agent.review_results,
         seconds=round(time.monotonic() - started, 2),
         error=error,
     )

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/cli.py

@@ -581,6 +581,7 @@ def cmd_bench(args) -> None:
             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,
+            review=cfg["review"] if args.review is None else args.review,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -775,6 +776,9 @@ 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(
+        "--review", choices=["auto", "off"], help="review each change before it counts (default: the setting)"
+    )
     p.add_argument(
         "--checks",
         metavar="auto|off|COMMAND",

{lcode_cli-0.31.0 → lcode_cli-0.33.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)"),
+    "review": ("off", str, "before the answer, check a change against the request and send problems back: auto | off"),
     "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"),

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/permissions.py

@@ -198,6 +198,7 @@ class Permissions:
         self.always: set[str] = set()
         self.rules = Rules()  # allow and deny lists from the settings (lcode.hooks)
         self.on_prompt = None  # called with the title before lcode asks the user (notification hooks)
+        self.read_line: Callable[[str], str] | None = None  # asks instead of input() (lcode.steer, during a request)
         # Decides instead of asking (lcode.api, lcode acp): True, False, or a message saying why not.
         self.approve: Callable[[dict], bool | str] | None = None
 
@@ -243,7 +244,8 @@ class Permissions:
         if kind == "mcp":
             scope = scope.replace(":", " › ", 1)
         try:
-            answer = input(f"  Allow? [y]es / [a]lways for '{scope}' this session / [n]o (+ optional reason): ")
+            question = f"  Allow? [y]es / [a]lways for '{scope}' this session / [n]o (+ optional reason): "
+            answer = (self.read_line or input)(question)
         except EOFError:
             return False, "The user denied this action (no input available)."
         answer = answer.strip()

{lcode_cli-0.31.0 → lcode_cli-0.33.0}/src/lcode/repl.py

@@ -36,6 +36,7 @@ from lcode.checkpoints import Checkpoint, CheckpointError, Restore
 from lcode.config import PERMISSION_MODES, STATE_DIR, ConfigError, format_tokens, parse_context
 from lcode.hardware import Hardware
 from lcode.ollama import OllamaError
+from lcode.steer import KeyReader, Steering
 from lcode.tools import IGNORE_DIRS
 
 COMMANDS = {
@@ -874,6 +875,7 @@ def git_command(agent: Agent, cmd: str, arg: str) -> None:
 
 def run_safely(agent: Agent, text: str) -> None:
     started = time.monotonic()
+    reader = start_steering(agent) if agent.interactive else None
     try:
         agent.run_turn(text)
     except KeyboardInterrupt:
@@ -881,10 +883,33 @@ def run_safely(agent: Agent, text: str) -> None:
     except OllamaError as e:
         agent.console.print(f"[red]{e}[/]")
     finally:
+        if reader is not None:
+            stop_steering(agent, reader)
         agent.save()
         agent.finished(text, time.monotonic() - started)
 
 
+def start_steering(agent: Agent) -> KeyReader | None:
+    """Read the keyboard while the request runs: a typed line becomes a note for the model, Esc pauses."""
+    steering = Steering()
+    reader = KeyReader(steering)
+    if not reader.start():
+        return None  # not a terminal lcode can read keys from (or Windows): the request runs as before
+    agent.steering = steering
+    agent.perms.read_line = steering.ask  # questions take the keyboard back meanwhile
+    return reader
+
+
+def stop_steering(agent: Agent, reader: KeyReader) -> None:
+    reader.stop()
+    agent.steering = None
+    agent.perms.read_line = None
+    unsent = reader.steering.leftover()
+    if unsent:
+        agent.unsent = unsent
+        agent.console.print(Text("✎ What you typed didn't reach the model; it's in the prompt below.", style="cyan"))
+
+
 def session_start(agent: Agent) -> None:
     """session_start hooks: their output is shown, and with feedback = true also given to the model."""
     for outcome in agent.hooks.run("session_start", {"cwd": str(agent.cwd), "session": agent.session_id}, agent.cwd):
@@ -1115,13 +1140,13 @@ def resume_session(agent: Agent, info: sessions.SessionInfo) -> None:
 
 def print_recap(agent: Agent) -> None:
     """Show the last request and the start of the last answer, so it's clear where things left off."""
-    last_user = next((m for m in reversed(agent.messages) if m.get("role") == "user"), None)
+    requests = context_tools.user_requests(agent.messages)  # the user's own words, not lcode's notes to the model
     last_answer = next(
         (m for m in reversed(agent.messages) if m.get("role") == "assistant" and m.get("content", "").strip()), None
     )
-    if not last_user:
+    if not requests:
         return
-    lines = [f"[bold]You:[/] {escape(sessions.title_from([last_user]))}"]
+    lines = [f"[bold]You:[/] {escape(sessions.title_from([{'role': 'user', 'content': requests[-1]}]))}"]
     if last_answer:
         answer = " ".join(last_answer["content"].split())
         answer = answer if len(answer) <= 300 else answer[:299].rstrip() + "…"
@@ -1153,7 +1178,8 @@ def repl(agent: Agent, prompt: str | None, hardware: Hardware, cont: bool = Fals
     while True:
         try:
             agent.console.print()
-            line = session.prompt(HTML("<ansicyan><b>❯ </b></ansicyan>")).strip()
+            unsent, agent.unsent = agent.unsent, ""
+            line = session.prompt(HTML("<ansicyan><b>❯ </b></ansicyan>"), default=unsent).strip()
         except KeyboardInterrupt:
             continue
         except EOFError:

lcode_cli-0.33.0/src/lcode/review.py

@@ -0,0 +1,103 @@
+"""A second look at a change before the answer goes to the user.
+
+Models claim more than they did: "users can now shrink the window" without having checked, half of a
+two-part request done, a debug print left behind. So when a request changed files, lcode asks the model to
+step back and check its change against the request (what was asked, what the diff shows, what the answer
+claims) before the answer counts. Real problems go back to the model once; the user sees a line about it.
+
+The review is asked on top of the conversation, not in a fresh one: the model server keeps the processed
+conversation cached, and a separate review prompt would push it out, so the next step would have to read the
+whole conversation again, tens of seconds on a small GPU. The question tells the model to judge only from the
+request and the diff.
+"""
+
+from __future__ import annotations
+
+import difflib
+from typing import TYPE_CHECKING
+
+from lcode.gitflow import parse_json
+
+if TYPE_CHECKING:
+    from lcode.agent import Agent
+
+MIN_CHANGED_LINES = 1  # even one line: a one-line bug fix is where a wrong fix hides
+MAX_PROBLEMS = 5
+SCHEMA = {
+    "type": "object",
+    "properties": {"problems": {"type": "array", "items": {"type": "string"}}},
+    "required": ["problems"],
+}
+PROMPT = """[lcode] Before your answer goes to the user, review your change as a strict reviewer would: judge it only by what the user asked and what the diff shows, not by what you meant to do.
+
+The user's request:
+<request>
+{request}
+</request>
+
+Your answer to them:
+<answer>
+{answer}
+</answer>
+
+{checks}The change (unified diff of the files changed in this request):
+<diff>
+{diff}
+</diff>
+
+Find real problems only, each one you can point to in the request or the diff:
+1. Something the user asked for that the change doesn't do, or only partly does.
+2. A claim in your answer that the diff doesn't support, or something called tested or working that nothing shows was run.
+3. A mistake in the diff: a bug, a broken edge case the request mentions, leftover debugging (prints, commented-out code), an unfinished TODO.
+No style preferences, no suggestions beyond the request. Answer in JSON: {{"problems": ["…"]}}, with an empty list when the change does what was asked."""
+
+FEEDBACK = """[lcode] A review of your change against the user's request found:
+{problems}
+
+Fix what's real; if a point is wrong, say why in your answer. Then finish."""
+
+
+def diff_of(before: dict[str, str | None], read, budget: int) -> tuple[str, int]:
+    """The unified diff of the files changed in the request, and how many lines it changes."""
+    parts, changed = [], 0
+    for path, old in before.items():
+        new = read(path)
+        if new is None or new == old:
+            continue
+        lines = list(
+            difflib.unified_diff((old or "").splitlines(True), new.splitlines(True), f"a/{path}", f"b/{path}", n=2)
+        )
+        changed += sum(1 for line in lines if line[:1] in "+-" and not line.startswith(("+++", "---")))
+        parts.append("".join(lines))
+    text = "".join(parts)
+    if len(text) > budget:
+        text = text[:budget] + f"\n[… the rest of the diff ({len(text) - budget} characters) is cut]"
+    return text, changed
+
+
+def run(agent: Agent, request: str, answer: str, diff: str) -> list[str]:
+    """Ask for the review; the problems it found (empty when none, or when the answer can't be read)."""
+    checks = ""
+    if agent.check_results:
+        last = agent.check_results[-1]
+        code = last.get("exit_code")
+        state = "passed" if code == 0 else "didn't run" if code is None else f"failed (exit code {code})"
+        checks = f"The project's checks (`{last.get('command')}`) {state} after the change.\n\n"
+    prompt = PROMPT.format(request=request[:4000], answer=answer[:3000] or "(none)", checks=checks, diff=diff)
+    payload = {
+        "model": agent.settings.model,
+        "messages": [*agent.messages, {"role": "user", "content": prompt}],
+        "tools": agent.tool_schemas(),  # as in the session, so the cached conversation is reused
+        "think": agent.settings.think,  # without reasoning it missed every gap it caught with it, and wasn't faster
+        "format": SCHEMA,
+        "keep_alive": agent.settings.keep_alive,
+        "options": agent.options(),
+    }
+    reply = agent.ollama.chat(payload)
+    data = parse_json((reply.get("message") or {}).get("content") or "")
+    problems = data.get("problems") if isinstance(data.get("problems"), list) else []
+    return [str(p).strip()[:500] for p in problems if str(p).strip()][:MAX_PROBLEMS]
+
+
+def feedback(problems: list[str]) -> str:
+    return FEEDBACK.format(problems="\n".join(f"- {p}" for p in problems))