lcode-cli 0.22.0__tar.gz → 0.24.0__tar.gz

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/CHANGELOG.md

@@ -6,6 +6,39 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.24.0] - 2026-10-10
+
+### Added
+
+- Ctrl+V in lcode's prompt pastes a screenshot: lcode reads the clipboard (with `wl-paste` on
+  Wayland, `xclip` on X11, `pngpaste` or `osascript` on macOS), saves the image and attaches it as
+  `@path`. Other clipboard content is pasted as text. `lcode doctor` shows whether it works here.
+- Image paths in a message are attached without `@`: absolute and `~` paths, quoted paths with
+  spaces, and `file://` paths dragged into the terminal. `@"path with spaces"` works for any file.
+
+### Fixed
+
+- An image path that doesn't exist is no longer ignored: lcode says so, and tells the model it can't
+  see that image, so it asks instead of guessing what the picture shows. See
+  [Images](https://nasser1941.github.io/lcode/usage/#images).
+
+## [0.23.0] - 2026-10-10
+
+### Added
+
+- lcode notices when the model goes round in circles, making the same tool call with the same result
+  again and again, as small models sometimes do. The third time in a request (the second, for a call
+  that failed) the result tells the model so; two more, and lcode ends the request (status `loop`,
+  exit code `4` with `lcode -p`). Results that change, and checks run after an edit, don't count.
+  `repeat_limit` changes the threshold; `0` turns it off. See
+  [When the model repeats itself](https://nasser1941.github.io/lcode/how-it-works/#when-the-model-repeats-itself).
+
+### Fixed
+
+- A tool call Ollama can't parse because its XML is broken (`XML syntax error … unexpected EOF`, from
+  models such as Qwen3.6 that write their calls in XML) is now sent back to the model to make again,
+  like a call with broken JSON, instead of ending the request with an error.
+
 ## [0.22.0] - 2026-10-06
 
 ### Added
@@ -491,7 +524,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.22.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.24.0...HEAD
+[0.24.0]: https://github.com/nasser1941/lcode/compare/v0.23.0...v0.24.0
+[0.23.0]: https://github.com/nasser1941/lcode/compare/v0.22.0...v0.23.0
 [0.22.0]: https://github.com/nasser1941/lcode/compare/v0.21.0...v0.22.0
 [0.21.0]: https://github.com/nasser1941/lcode/compare/v0.20.0...v0.21.0
 [0.20.0]: https://github.com/nasser1941/lcode/compare/v0.19.0...v0.20.0

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.22.0
+Version: 0.24.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.22.0 → lcode_cli-0.24.0}/docs/automation.md

@@ -23,7 +23,8 @@ lcode -p "Explain the retry logic" --output stream-json --max-steps 20
 | `--allowed-tools LIST` | Only these tools, e.g. `"read_file,grep,glob,bash"` |
 
 lcode's usual output goes to stderr, so stdout holds only the JSON. The exit code says how it
-went: `0` success, `1` an error, `3` stopped at `--max-steps`, `130` interrupted.
+went: `0` success, `1` an error, `3` stopped at `--max-steps`, `4` stopped because the model
+[kept repeating itself](how-it-works.md#when-the-model-repeats-itself), `130` interrupted.
 
 ### The result
 
@@ -49,7 +50,7 @@ went: `0` success, `1` an error, `3` stopped at `--max-steps`, `130` interrupted
 
 | Field | |
 |---|---|
-| `status` | `success`, `error`, `max_steps` or `interrupted` |
+| `status` | `success`, `error`, `max_steps`, `loop` (the model kept repeating the same call) or `interrupted` |
 | `text` | The model's final answer |
 | `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 |

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/docs/configuration.md

@@ -42,6 +42,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 |
+| `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 |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Besides these settings, `config.toml` can hold [hooks](hooks.md) (`[[hooks]]`) and

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/docs/how-it-works.md

@@ -29,6 +29,25 @@ All tools return text, and failures come back to the model as `Error: …` messa
 crashing the session, so the model can correct itself (for example re-read a file when an edit
 didn't match).
 
+### When the model repeats itself
+
+Small models sometimes fall into a loop: they make a call, get a result, and make the very same call
+again, and again. lcode counts, within a request, the calls that repeat an earlier one exactly: the
+same tool, the same arguments and the same result.
+
+- **At the third one** (the second, when the call failed) the result gets a note: the call returned
+  the same thing several times, so the model should use what it got, try something different, or
+  tell you what's blocking it.
+- **Two more,** and lcode ends the request with
+  `Stopped: the model kept making the same call with the same result`. The JSON output's status is
+  `loop`.
+
+A result that changes isn't a repeat, so a test that's run again after a fix, or a background job
+that's checked while it runs, never adds up. A call that may have changed something, like an edit or
+a shell command that isn't read-only, starts the count again for the other calls: checking the build
+after each edit is fine. Change the threshold with `lcode config set repeat_limit 5`, or turn it off
+with `0`.
+
 ## Subagents
 
 The `agent` tool starts a [subagent](agents.md): another agent loop with its own conversation, the

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/docs/quickstart.md

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

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/docs/usage.md

@@ -154,8 +154,19 @@ lcode can look at screenshots, mockups, diagrams and photos:
 ❯ make the settings page match @design/settings.png
 ```
 
-- Attach an image with `@path`, like a file. lcode describes it in detail, with all visible text
-  transcribed and with your question in mind, and the model works from that description.
+- **Paste a screenshot with ++ctrl+v++.** A terminal can only paste text, so lcode reads the
+  clipboard itself, saves the image in its state folder (`~/.local/state/lcode/pasted/`, the last
+  50) and puts `@path` in the prompt. Anything else on the clipboard is pasted as text. It needs
+  `wl-clipboard` on Wayland or `xclip` on X11 (`sudo apt install wl-clipboard`); on macOS it works
+  as is, and faster with `brew install pngpaste`. `lcode doctor` shows whether it works.
+- Attach an image with `@path`, like a file, or just write its path: `/tmp/shot.png`,
+  `~/Pictures/bug.png`, `'./shots/My Shot.png'` and `file://` paths dragged into the terminal are
+  attached too. lcode describes the image in detail, with all visible text transcribed and with your
+  question in mind, and the model works from that description.
+- **A path to an image that doesn't exist** is reported right away
+  (`/tmp/pasted-image-.png doesn't exist, so the model can't see it`), and the model is told it
+  can't see the image, so it asks instead of guessing what it shows. A bare name such as `logo.png`
+  may be a file you want created, so it's left alone.
 - The model can open images itself with the `view_image` tool, for example a screenshot a test wrote.
 - Screenshots that [MCP](mcp.md) tools return, such as the Playwright browser's, are described too.
 

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/__init__.py

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

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/acp.py

@@ -48,7 +48,12 @@ KINDS = {
     "bash": "execute", "web_search": "fetch", "web_fetch": "fetch", "agent": "think", "todo_write": "think",
     "present_plan": "switch_mode", "bash_output": "read", "bash_stop": "execute",
 }  # fmt: skip
-STOP = {"success": "end_turn", "max_steps": "max_turn_requests", "interrupted": "cancelled"}
+STOP = {
+    "success": "end_turn",
+    "max_steps": "max_turn_requests",
+    "loop": "max_turn_requests",
+    "interrupted": "cancelled",
+}
 MAX_INLINE = 200_000  # bytes of a file the editor attaches that go into the prompt
 METHOD_NOT_FOUND, INVALID_PARAMS, INTERNAL_ERROR, NOT_FOUND = -32601, -32602, -32603, -32002
 

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/action.py

@@ -297,7 +297,7 @@ def answer(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
     )
     with open_session(inputs, cwd) as session:
         result = session.run(prompt)
-        if result.status not in ("success", "max_steps"):
+        if result.status not in ("success", "max_steps", "loop"):
             raise ActionError(result.error or result.status)
         reply = result.text.strip() or "(no answer)"
         changed = git(cwd, "status", "--porcelain").strip()
@@ -336,6 +336,8 @@ def answer(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
             reply += f"\n\n{link}"
         if result.status == "max_steps":
             reply += f"\n\n(Stopped after {inputs.max_steps} steps.)"
+        elif result.status == "loop":
+            reply += "\n\n(Stopped: the model kept repeating the same call.)"
         hub.comment(task.number, reply[:MAX_COMMENT] + footer(result))
 
 
@@ -349,7 +351,7 @@ def review(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
         prompt = gitflow.review_prompt(session.agent, base)
         session.agent.no_changes = "This is a review, so nothing can be changed: report what should change instead."
         result = session.run(prompt)
-    if result.status not in ("success", "max_steps"):
+    if result.status not in ("success", "max_steps", "loop"):
         raise ActionError(result.error or result.status)
     hub.comment(task.number, f"**lcode review**\n\n{result.text.strip()[:MAX_COMMENT]}{footer(result)}")
 

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/agent.py

@@ -11,6 +11,7 @@ import shutil
 import subprocess
 import threading
 import time
+import urllib.parse
 import uuid
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -32,6 +33,7 @@ from lcode.mcp import McpManager
 from lcode.ollama import Ollama, OllamaError
 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.tools import (
     LSP_SCHEMA,
@@ -57,9 +59,20 @@ MAX_STEPS_PER_TURN = 150
 EVENT_OUTPUT = 4000  # characters of a tool's output in an event
 # How a tool result starts when the call failed or wasn't allowed (an "error" in events and results).
 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  # safety cap on tool-call iterations for one request
+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")
 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
+# @path, @"path with spaces" or @'path'
+MENTION = re.compile(r"""(?<!\S)@(?:"([^"\n]+)"|'([^'\n]+)'|([\w./~\-]+))""")
+# An image path written in a message: in quotes, or without spaces (a space escaped as "\ " is fine), or as a
+# file:// address, the way terminals paste a dragged file.
+IMAGE_PATH = re.compile(
+    r"""(['"])((?:file://)?[^'"\n]+?\.(?:png|jpe?g|webp|gif))\1"""
+    r"""|(?<![^\s(])((?:[^\s\\'"(]|\\ )+?\.(?:png|jpe?g|webp|gif))(?=[\s,;:!?)\]]|\.(?:\s|$)|$)""",
+    re.IGNORECASE,
+)
 PROJECT_FILES = ("AGENTS.md", "LCODE.md", "CLAUDE.md")
 
 SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent running in the user's terminal on their own machine, powered by the local model {model}. You help the user understand codebases, answer questions about code, write scripts (Python by default), fix bugs, refactor, and run commands.
@@ -216,6 +229,7 @@ class Settings:
     notify: bool = False  # desktop notifications after long requests (lcode.notify)
     notify_after: int = 30  # seconds: a request this long notifies when it's done or waits for an answer
     max_parallel_agents: int = 1
+    repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
 
 
 class Agent:
@@ -267,7 +281,8 @@ class Agent:
         # Decides on a presented plan instead of asking in the terminal: "ask", "auto-edit", or why not.
         self.plan_review: Callable[[str, str], str] | None = None
         self.max_steps = MAX_STEPS_PER_TURN
-        self.turn_status = ""  # how the last request ended: success, max_steps
+        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
         self.ctx_used = 0
         self.last_speed = 0.0
@@ -809,7 +824,9 @@ 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.repeats.reset()
         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
@@ -834,17 +851,22 @@ class Agent:
                     }
                 )
             except OllamaError as e:
-                if "error parsing tool call" not in str(e) or malformed >= MAX_MALFORMED_CALL_RETRIES:
+                if not any(m in str(e) for m in MALFORMED_CALL) or malformed >= MAX_MALFORMED_CALL_RETRIES:
                     raise
                 malformed += 1
-                reason = str(e).rsplit("err=", 1)[-1].strip() if "err=" in str(e) else "invalid JSON"
+                if "err=" in str(e):
+                    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"
+                else:
+                    reason = "invalid JSON"
                 self.console.print("[yellow]The model wrote a malformed tool call; asking it to try again.[/]")
                 self.messages.append(
                     {
                         "role": "user",
-                        "content": f"[lcode] Your last tool call could not be parsed ({reason}): its arguments "
-                        "must be one complete, valid JSON object. Make the call again. If it writes a file, "
-                        "make sure the whole content is included and properly escaped.",
+                        "content": f"[lcode] Your last tool call could not be parsed ({reason}): it must be "
+                        "complete and well-formed, with every argument closed. Make the call again. If it writes "
+                        "a file, make sure the whole content is included and properly escaped.",
                     }
                 )
                 continue
@@ -892,6 +914,15 @@ 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"))
+                verdict = self.repeats.check(name, args, result)
+                if verdict.note:
+                    result += verdict.note
+                    what = "stopping the request" if verdict.stop else "told the model"
+                    self.console.print(
+                        Text(f"  ⎿ same call, same result, {verdict.count} times: {what}", style="yellow")
+                    )
+                    if verdict.stop:
+                        looping = self.describe_call(name, args)
                 tool_msg = {"role": "tool", "tool_name": name, "content": result}
                 if call.get("id"):
                     tool_msg["tool_call_id"] = call["id"]
@@ -905,6 +936,27 @@ class Agent:
                         "output": result[:EVENT_OUTPUT] + ("…" if len(result) > EVENT_OUTPUT else ""),
                     }
                 )
+                if looping:
+                    for rest in calls[i + 1 :]:
+                        skipped = {
+                            "role": "tool",
+                            "tool_name": rest.get("function", {}).get("name", ""),
+                            "content": "Not run: lcode stopped the request before this call.",
+                        }
+                        if rest.get("id"):
+                            skipped["tool_call_id"] = rest["id"]
+                        self.messages.append(skipped)
+                    break
+            if looping:
+                self.turn_status = "loop"
+                self.console.print(
+                    Text(
+                        f"Stopped: the model kept making the same call with the same result: {looping}. Tell it "
+                        "what to do differently, or try again.",
+                        style="yellow",
+                    )
+                )
+                return
         else:
             self.turn_status = "max_steps"
             self.console.print(f"[yellow]Stopped after {self.max_steps} steps.[/]")
@@ -923,30 +975,68 @@ class Agent:
         )
 
     def expand_mentions(self, text: str) -> str:
-        """Inline files referenced as @path in the user's message; @name of an agent asks for that agent."""
-        attached = []
-        for ref in re.findall(r"(?<!\S)@([\w./~\-]+)", text):
+        """Attach what the user's message points to: files and folders written as @path, image paths (with or
+        without @), and @name of an agent asks for that agent. An image path that doesn't exist is reported to
+        the user and the model, so the model doesn't guess what the image shows."""
+        attached: list[str] = []
+        seen: set[Path] = set()
+        question = MENTION.sub("", text)
+
+        def attach_image(p: Path) -> None:
+            try:
+                description = self.look(p, question)
+                who = f' described_by="{self.vision_model()}"'
+            except ToolError as e:
+                description, who = f"(lcode couldn't look at this image: {e})", ""
+                self.console.print(Text(f"  ⎿ {e}", style="yellow"))
+            else:
+                self.console.print(Text(f"  ⎿ looked at {self.tools.rel(p)}", style="dim"))
+            attached.append(f'<image path="{self.tools.rel(p)}"{who}>\n{description}\n</image>')
+
+        def missing_image(shown: str) -> None:
+            self.console.print(
+                Text(f"  ⎿ {shown} doesn't exist, so the model can't see it. Paste images with Ctrl+V.", style="yellow")
+            )
+            attached.append(
+                f"[lcode: the user's message mentions the image {shown}, but there's no such file, so it wasn't "
+                "attached and you can't see it. Don't guess what it shows: ask the user to paste it again (Ctrl+V "
+                "in lcode's prompt) or to describe it.]"
+            )
+
+        for match in MENTION.finditer(text):
+            ref = next(g for g in match.groups() if g)
             p = self.tools.resolve(ref)
+            seen.add(p)
             name = ref.removeprefix("agent-")
             if not p.exists() and self.settings.subagents and name in self.agent_types():
                 attached.append(f'[The user wants the {name} agent for this: call the agent tool with type "{name}".]')
                 continue
             if p.is_file() and vision.is_image(p):
-                try:
-                    description = self.look(p, re.sub(r"(?<!\S)@[\w./~\-]+", "", text))
-                    who = f' described_by="{self.vision_model()}"'
-                except ToolError as e:
-                    description, who = f"(lcode couldn't look at this image: {e})", ""
-                    self.console.print(Text(f"  ⎿ {e}", style="yellow"))
-                else:
-                    self.console.print(Text(f"  ⎿ looked at {self.tools.rel(p)}", style="dim"))
-                attached.append(f'<image path="{self.tools.rel(p)}"{who}>\n{description}\n</image>')
+                attach_image(p)
             elif p.is_file() and not is_binary(p) and p.stat().st_size < 200_000:
                 attached.append(f'<file path="{self.tools.rel(p)}">\n{p.read_text(errors="replace")}\n</file>')
                 self.tools.read_mtimes[str(p)] = p.stat().st_mtime
                 self.console.print(Text(f"  ⎿ attached {self.tools.rel(p)}", style="dim"))
             elif p.is_dir():
                 attached.append(f'<directory path="{self.tools.rel(p)}">\n{tree(p, 2)}\n</directory>')
+            elif not p.exists() and vision.is_image(p):
+                missing_image(ref)
+        for match in IMAGE_PATH.finditer(text):
+            quoted, raw = bool(match.group(2)), match.group(2) or match.group(3)
+            if raw.startswith("@") or "://" in raw.removeprefix("file://"):
+                continue  # attached above, or a web address
+            if raw.startswith("file://"):
+                shown = urllib.parse.unquote(raw.removeprefix("file://"))
+            else:
+                shown = raw.replace("\\ ", " ")
+            p = self.tools.resolve(shown)
+            if p in seen:
+                continue
+            seen.add(p)
+            if p.is_file():
+                attach_image(p)
+            elif quoted or raw.startswith(("/", "~", "./", "../", "file://")):
+                missing_image(shown)  # a name without a folder may be a file to create: no warning
         return text + ("\n\n" + "\n\n".join(attached) if attached else "")
 
     # -- context management

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/api.py

@@ -35,8 +35,8 @@ if TYPE_CHECKING:
     from lcode.hardware import Hardware
 
 SCHEMA_VERSION = 1
-STATUSES = ("success", "error", "max_steps", "interrupted")
-EXIT_CODES = {"success": 0, "error": 1, "max_steps": 3, "interrupted": 130}
+STATUSES = ("success", "error", "max_steps", "loop", "interrupted")
+EXIT_CODES = {"success": 0, "error": 1, "max_steps": 3, "loop": 4, "interrupted": 130}
 OLLAMA_INSTALL = {
     "linux": "curl -fsSL https://ollama.com/install.sh | sh",
     "darwin": "brew install ollama   (or download it from https://ollama.com/download)",
@@ -69,7 +69,7 @@ class Options:
 class Result:
     """How a request went. `to_json()` is what `lcode -p --output json` prints."""
 
-    status: str  # success, error, max_steps or interrupted
+    status: str  # success, error, max_steps, loop (stopped: the model kept repeating itself) or interrupted
     text: str  # the model's final answer
     session_id: str
     model: str
@@ -194,6 +194,7 @@ def open_agent(cwd: Path, options: Options, console: Console, hw: Hardware | Non
         embed_model=cfg["embed_model"],
         notify=cfg["notify"],
         notify_after=cfg["notify_after"],
+        repeat_limit=cfg["repeat_limit"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.interactive = options.interactive
@@ -272,7 +273,7 @@ def run_request(agent: Agent, prompt: str) -> Result:
 
     try:
         agent.run_turn(prompt)
-        status = "max_steps" if agent.turn_status == "max_steps" else "success"
+        status = agent.turn_status if agent.turn_status in ("max_steps", "loop") else "success"
     except KeyboardInterrupt:
         status, error = "interrupted", "interrupted before the request was done"
     except ModelError as e:

{lcode_cli-0.22.0 → lcode_cli-0.24.0}/src/lcode/cli.py

@@ -346,6 +346,10 @@ def cmd_doctor(args) -> None:
             line("Vision", "off; set vision_model to a model the server serves that can see images", None)
         else:
             line("Vision", "off" if cfg["vision_model"] == "off" else vision.INSTALL_HINT, None)
+        if seer:
+            from lcode import clipboard
+
+            line("Clipboard", *clipboard.status())
         if limits.get(model):
             line(
                 "Limit",

lcode_cli-0.24.0/src/lcode/clipboard.py

@@ -0,0 +1,139 @@
+"""Paste from the clipboard with Ctrl+V, images included.
+
+A terminal can only paste text, so a screenshot never reaches lcode that way. On Ctrl+V lcode reads the
+clipboard itself: with wl-paste on Wayland, xclip on X11, and pngpaste or osascript on macOS. An image is
+saved in lcode's state folder and goes into the prompt as `@path`, so it's attached like any other image;
+anything else is pasted as text.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from lcode import config
+
+TIMEOUT = 5  # seconds for a clipboard tool
+IMAGE_TYPES = ("image/png", "image/jpeg", "image/webp", "image/gif")
+SUFFIXES = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/gif": ".gif"}
+KEEP = 50  # pasted images kept; older ones are removed
+
+
+@dataclass
+class Paste:
+    image: Path | None = None  # a saved image
+    text: str = ""  # or text
+    problem: str = ""  # why nothing could be pasted
+
+
+def run(argv: list[str]) -> bytes | None:
+    try:
+        done = subprocess.run(argv, capture_output=True, timeout=TIMEOUT, check=False)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return done.stdout if done.returncode == 0 else None
+
+
+def folder() -> Path:
+    return config.STATE_DIR / "pasted"
+
+
+def save(data: bytes, suffix: str) -> Path:
+    where = folder()
+    where.mkdir(parents=True, exist_ok=True)
+    old = sorted(where.glob("pasted-*"))  # the names sort by time
+    for path in old[: max(0, len(old) - KEEP + 1)]:
+        path.unlink(missing_ok=True)
+    now = time.time_ns()
+    stamp = f"{time.strftime('%Y%m%d-%H%M%S', time.localtime(now / 1e9))}-{now % 1_000_000_000:09d}"
+    path = where / f"pasted-{stamp}{suffix}"
+    n = 1
+    while path.exists():
+        n += 1
+        path = where / f"pasted-{stamp}-{n}{suffix}"
+    path.write_bytes(data)
+    return path
+
+
+def pick(types: list[str]) -> str | None:
+    return next((t for t in IMAGE_TYPES if t in types), None)
+
+
+def paste() -> Paste:
+    """Whatever is on the clipboard: an image (saved to a file) or text."""
+    if sys.platform == "darwin":
+        return paste_mac()
+    if os.environ.get("WAYLAND_DISPLAY") and shutil.which("wl-paste"):
+        return paste_with(
+            ["wl-paste", "--list-types"],
+            lambda kind: ["wl-paste", "--no-newline", "--type", kind],
+            ["wl-paste", "--no-newline"],
+        )
+    if os.environ.get("DISPLAY") and shutil.which("xclip"):
+        return paste_with(
+            ["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"],
+            lambda kind: ["xclip", "-selection", "clipboard", "-t", kind, "-o"],
+            ["xclip", "-selection", "clipboard", "-o"],
+        )
+    return Paste(problem=status()[0])
+
+
+def status() -> tuple[str, bool | None]:
+    """Whether Ctrl+V can paste images here, and if not, what to do (for the paste and `lcode doctor`)."""
+    if sys.platform == "darwin":
+        return "Ctrl+V pastes images" + (" (with pngpaste)" if shutil.which("pngpaste") else ""), True
+    if os.environ.get("WAYLAND_DISPLAY"):
+        if shutil.which("wl-paste"):
+            return "Ctrl+V pastes images (with wl-paste)", True
+        return "To paste images with Ctrl+V, install wl-clipboard (for example `sudo apt install wl-clipboard`).", None
+    if os.environ.get("DISPLAY"):
+        if shutil.which("xclip"):
+            return "Ctrl+V pastes images (with xclip)", True
+        return "To paste images with Ctrl+V, install xclip (for example `sudo apt install xclip`).", None
+    return "There's no clipboard here (no desktop session), so give an image by its path.", None
+
+
+def paste_with(list_types: list[str], get, get_text: list[str]) -> Paste:
+    types = (run(list_types) or b"").decode(errors="replace").split()
+    kind = pick(types)
+    if kind:
+        data = run(get(kind))
+        if data:
+            return Paste(image=save(data, SUFFIXES[kind]))
+    text = run(get_text)
+    if text:
+        return Paste(text=text.decode(errors="replace"))
+    return Paste(problem="The clipboard is empty.")
+
+
+def paste_mac() -> Paste:
+    if shutil.which("pngpaste"):
+        data = run(["pngpaste", "-"])
+        if data:
+            return Paste(image=save(data, ".png"))
+    else:
+        target = folder() / ".clipboard.png"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.unlink(missing_ok=True)
+        script = [
+            "try",
+            "set png to (the clipboard as «class PNGf»)",
+            f'set f to open for access POSIX file "{target}" with write permission',
+            "write png to f",
+            "close access f",
+            "end try",
+        ]
+        run(["osascript", *[arg for line in script for arg in ("-e", line)]])
+        if target.exists() and target.stat().st_size:
+            data = target.read_bytes()
+            target.unlink(missing_ok=True)
+            return Paste(image=save(data, ".png"))
+    text = run(["pbpaste"])
+    if text:
+        return Paste(text=text.decode(errors="replace"))
+    return Paste(problem="The clipboard is empty.")

{lcode_cli-0.22.0 → lcode_cli-0.24.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)"),
+    "repeat_limit": (3, int, "identical tool calls with identical results before lcode steps in (0: never)"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {