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

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

@@ -6,6 +6,22 @@ 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
@@ -508,7 +524,8 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.23.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

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

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

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

{lcode_cli-0.23.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.23.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.23.0"
+__version__ = "0.24.0"
 
 API = ("Session", "Result", "Options", "SetupError")
 

{lcode_cli-0.23.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
@@ -63,6 +64,15 @@ MAX_MALFORMED_CALL_RETRIES = 2  # Ollama rejects tool calls whose arguments aren
 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.
@@ -965,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.23.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.23.0 → lcode_cli-0.24.0}/src/lcode/repl.py

@@ -14,6 +14,7 @@ import time
 from pathlib import Path
 
 from prompt_toolkit import PromptSession
+from prompt_toolkit.application import run_in_terminal
 from prompt_toolkit.completion import Completer, Completion
 from prompt_toolkit.formatted_text import HTML
 from prompt_toolkit.history import FileHistory
@@ -26,7 +27,7 @@ from rich.rule import Rule
 from rich.table import Table
 from rich.text import Text
 
-from lcode import __version__, backends, catalog, extensions, gitflow, limits, sessions, web
+from lcode import __version__, backends, catalog, clipboard, extensions, gitflow, limits, sessions, web
 from lcode import context as context_tools
 from lcode import memory as memory_notes
 from lcode.agent import AUTO_COMPACT_RATIO, INIT_PROMPT, Agent
@@ -101,6 +102,13 @@ class InputCompleter(Completer):
                 yield Completion(completion, start_position=-len(fragment))
 
 
+def mention(path: Path) -> str:
+    """How a file goes into the prompt: @path, with ~ for the home folder, in quotes if it has spaces."""
+    home = Path.home()
+    shown = f"~/{path.relative_to(home)}" if path.is_relative_to(home) else str(path)
+    return f'@"{shown}"' if " " in shown else f"@{shown}"
+
+
 def build_session(agent: Agent) -> PromptSession:
     kb = KeyBindings()
 
@@ -119,6 +127,19 @@ def build_session(agent: Agent) -> PromptSession:
     def _newline(event):
         event.current_buffer.insert_text("\n")
 
+    @kb.add("c-v")
+    def _paste(event):
+        """Paste the clipboard: an image becomes @path (terminals can't paste images), anything else is text."""
+        got = clipboard.paste()
+        buf = event.current_buffer
+        if got.image:
+            before = buf.document.char_before_cursor
+            buf.insert_text(("" if not before or before.isspace() else " ") + mention(got.image) + " ")
+        elif got.text:
+            buf.insert_text(got.text.replace("\r\n", "\n"))
+        else:
+            run_in_terminal(lambda: agent.console.print(Text(f"  {got.problem}", style="yellow")))
+
     @kb.add("s-tab")
     def _cycle_mode(event):
         agent.perms.cycle()

lcode_cli-0.24.0/tests/test_clipboard.py

@@ -0,0 +1,118 @@
+import os
+import stat
+
+import pytest
+
+from lcode import clipboard, config, repl
+
+PNG = b"\x89PNG\r\n\x1a\nfake"
+
+
+def tool(bin_dir, name, script):
+    path = bin_dir / name
+    path.write_text("#!/bin/sh\n" + script)
+    path.chmod(path.stat().st_mode | stat.S_IEXEC)
+
+
+@pytest.fixture
+def desktop(tmp_path, monkeypatch):
+    """No clipboard tools and no desktop session, until a test adds them."""
+    bin_dir = tmp_path / "bin"
+    bin_dir.mkdir()
+    for name in ("sh", "cat", "printf"):
+        os.symlink(f"/bin/{name}" if os.path.exists(f"/bin/{name}") else f"/usr/bin/{name}", bin_dir / name)
+    monkeypatch.setenv("PATH", str(bin_dir))
+    monkeypatch.delenv("WAYLAND_DISPLAY", raising=False)
+    monkeypatch.delenv("DISPLAY", raising=False)
+    monkeypatch.setattr(clipboard.sys, "platform", "linux")
+    monkeypatch.setattr(config, "STATE_DIR", tmp_path / "state")
+    (tmp_path / "shot.png").write_bytes(PNG)
+    return bin_dir
+
+
+def test_an_image_on_wayland_is_saved(desktop, tmp_path, monkeypatch):
+    monkeypatch.setenv("WAYLAND_DISPLAY", "wayland-0")
+    tool(
+        desktop,
+        "wl-paste",
+        f'if [ "$1" = "--list-types" ]; then printf "text/plain\\nimage/png\\n"; '
+        f'elif [ "$2" = "--type" ] && [ "$3" = "image/png" ]; then cat {tmp_path / "shot.png"}; '
+        "else exit 1; fi\n",
+    )
+    got = clipboard.paste()
+    assert got.image is not None and got.image.read_bytes() == PNG
+    assert got.image.parent == tmp_path / "state" / "pasted" and got.image.suffix == ".png"
+    assert clipboard.paste().image != got.image  # a second paste doesn't overwrite the first
+
+
+def test_text_on_x11_is_pasted_as_text(desktop, monkeypatch):
+    monkeypatch.setenv("DISPLAY", ":0")
+    tool(
+        desktop,
+        "xclip",
+        'if [ "$4" = "TARGETS" ]; then printf "UTF8_STRING\\nTARGETS\\n"; else printf "hello world"; fi\n',
+    )
+    got = clipboard.paste()
+    assert got.image is None and got.text == "hello world"
+    assert clipboard.status() == ("Ctrl+V pastes images (with xclip)", True)
+
+
+def test_missing_tools_say_what_to_install(desktop, monkeypatch):
+    assert "no clipboard here" in clipboard.paste().problem
+    monkeypatch.setenv("DISPLAY", ":0")
+    assert "install xclip" in clipboard.paste().problem
+    monkeypatch.setenv("WAYLAND_DISPLAY", "wayland-0")
+    assert "install wl-clipboard" in clipboard.paste().problem and clipboard.status()[1] is None
+    tool(desktop, "wl-paste", "exit 1\n")
+    assert clipboard.paste().problem == "The clipboard is empty."
+
+
+def test_an_image_on_a_mac(desktop, tmp_path, monkeypatch):
+    monkeypatch.setattr(clipboard.sys, "platform", "darwin")
+    tool(desktop, "pngpaste", f'[ "$1" = "-" ] && cat {tmp_path / "shot.png"}\n')
+    assert clipboard.paste().image.read_bytes() == PNG
+
+
+def test_a_mac_without_pngpaste_asks_osascript(desktop, tmp_path, monkeypatch):
+    monkeypatch.setattr(clipboard.sys, "platform", "darwin")
+    target = tmp_path / "state" / "pasted" / ".clipboard.png"
+    tool(desktop, "osascript", f"cat {tmp_path / 'shot.png'} > {target}\n")
+    got = clipboard.paste()
+    assert got.image.read_bytes() == PNG and not target.exists()
+    tool(desktop, "osascript", "exit 0\n")
+    tool(desktop, "pbpaste", "printf 'some text'\n")
+    assert clipboard.paste().text == "some text"
+
+
+def test_old_pastes_are_cleaned_up(desktop, monkeypatch):
+    monkeypatch.setattr(clipboard, "KEEP", 3)
+    paths = [clipboard.save(PNG, ".png") for _ in range(5)]
+    left = sorted((config.STATE_DIR / "pasted").glob("pasted-*"))
+    assert len(left) == 3 and paths[-1] in left and paths[0] not in left
+
+
+def test_a_pasted_image_goes_into_the_prompt_as_a_mention(tmp_path, monkeypatch):
+    monkeypatch.setattr(repl.Path, "home", lambda: tmp_path)
+    assert repl.mention(tmp_path / "state" / "pasted-1.png") == "@~/state/pasted-1.png"
+    assert repl.mention(tmp_path / "My Shots" / "a.png") == '@"~/My Shots/a.png"'
+    assert repl.mention(tmp_path.parent / "x.png") == f"@{tmp_path.parent / 'x.png'}"
+
+
+def test_ctrl_v_puts_the_image_or_text_in_the_prompt(make_agent, monkeypatch, tmp_path):
+    from types import SimpleNamespace
+
+    from prompt_toolkit.buffer import Buffer
+    from prompt_toolkit.keys import Keys
+
+    monkeypatch.setattr(repl, "STATE_DIR", tmp_path)
+    session = repl.build_session(make_agent())
+    (binding,) = session.key_bindings.get_bindings_for_keys((Keys.ControlV,))
+    buffer = Buffer(multiline=True)
+    buffer.insert_text("why is this broken?")
+    shot = tmp_path / "pasted-1.png"
+    monkeypatch.setattr(repl.clipboard, "paste", lambda: repl.clipboard.Paste(image=shot))
+    binding.handler(SimpleNamespace(current_buffer=buffer))
+    assert buffer.text == f"why is this broken? {repl.mention(shot)} "
+    monkeypatch.setattr(repl.clipboard, "paste", lambda: repl.clipboard.Paste(text="line 1\r\nline 2"))
+    binding.handler(SimpleNamespace(current_buffer=buffer))
+    assert buffer.text.endswith(" line 1\nline 2")

{lcode_cli-0.23.0 → lcode_cli-0.24.0}/tests/test_vision.py

@@ -102,3 +102,34 @@ def test_view_image_respects_the_sandbox(make_agent, tmp_path_factory):
     outside.write_bytes(PNG)
     agent = seeing(make_agent(sandbox="docker"), "qwen3.6:35b-a3b-coding")
     assert agent.tools.run("view_image", {"path": str(outside)}).startswith("Error:")
+
+
+def test_image_paths_are_attached_without_an_at(make_agent, repo):
+    (repo / "shots").mkdir()
+    (repo / "shots" / "My Shot.png").write_bytes(PNG)
+    (repo / "bug.png").write_bytes(PNG)
+    agent = seeing(make_agent(), "qwen3.6:35b-a3b-coding")
+    text = agent.expand_mentions(f"compare {repo / 'bug.png'} with './shots/My Shot.png', and @bug.png again")
+    assert text.count("<image") == 2
+    assert '<image path="bug.png"' in text and '<image path="shots/My Shot.png"' in text
+    uri = agent.expand_mentions(f"dragged in: file://{repo}/shots/My%20Shot.png")
+    assert '<image path="shots/My Shot.png"' in uri
+    quoted = agent.expand_mentions('see @"shots/My Shot.png"')
+    assert '<image path="shots/My Shot.png"' in quoted
+
+
+def test_a_missing_image_is_reported_not_guessed(make_agent):
+    agent = seeing(make_agent([reply("Please paste it again.")]), "qwen3.6:35b-a3b-coding")
+    agent.run_turn("now we see something like /tmp/pasted-image-.png")
+    sent = agent.messages[1]["content"]
+    assert "[lcode: the user's message mentions the image /tmp/pasted-image-.png, but there's no such file" in sent
+    assert "Don't guess what it shows" in sent and "<image" not in sent
+    assert "/tmp/pasted-image-.png doesn't exist, so the model can't see it" in output(agent)
+    assert agent.ollama.chats == []  # nothing to look at
+    assert "no such file" in agent.expand_mentions("look at @gone.png")
+
+
+def test_image_names_without_a_folder_may_be_new_files(make_agent):
+    agent = make_agent()
+    text = "rename logo.png to icon.png and see https://example.com/banner.png"
+    assert agent.expand_mentions(text) == text