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

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

@@ -6,6 +6,35 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.26.0] - 2026-10-10
+
+### Added
+
+- lcode checks for secrets before the model runs `git commit` or `git push`: passwords, keys and
+  tokens in code or configuration, credentials in URLs (`rtsp://user:pass@…`), private keys,
+  tokens with a known form, and `.env` files, in the lines a commit adds or the commits a push
+  sends. In `ask` mode you decide; in `auto-edit` and `yolo` the command doesn't run, and the model
+  is told to move the secret out of the code. `/commit` and `/pr` show the findings before you
+  confirm, and the GitHub Action doesn't commit at all. `lcode: allow-secret` in a comment allows a
+  line; `secret_check = false` turns the check off. See
+  [Secrets in commits](https://nasser1941.github.io/lcode/usage/#secrets-in-commits).
+
+## [0.25.0] - 2026-10-10
+
+### Changed
+
+- The model is told what counts as checking its work: run what it changed the way it will be used,
+  reproduce each reported problem before fixing it, check what it can't see (GUIs, web pages,
+  layouts) without a screen, for example with Qt's `offscreen` platform, a headless browser or a
+  rendered image, and never call something tested or done without having run it. See
+  [Checking its own work](https://nasser1941.github.io/lcode/how-it-works/#checking-its-own-work).
+
+### Added
+
+- `lcode bench --tasks runtime-bug`: a bug that shows only when the code runs, a camera wall whose
+  window grows with every video frame. Reading the code suggests band-aids that fail its hidden
+  test. It isn't in the default set.
+
 ## [0.24.0] - 2026-10-10
 
 ### Added
@@ -524,7 +553,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.24.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.26.0...HEAD
+[0.26.0]: https://github.com/nasser1941/lcode/compare/v0.25.0...v0.26.0
+[0.25.0]: https://github.com/nasser1941/lcode/compare/v0.24.0...v0.25.0
 [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

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

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

@@ -90,6 +90,8 @@ with Session("path/to/repo", permission_mode="auto-edit") as session:
 - **Events while it runs:** `session.stream(prompt)` yields the events above, ending with the result.
 - **Permissions:** pass `approve` to decide permission requests. It gets
   `{"kind": "bash", "title": "…", "target": "pytest -q"}`; without it, every request is refused.
+  A `git commit` or `git push` that would add [what looks like a secret](usage.md#secrets-in-commits)
+  comes as `{"kind": "secret", …}` in `ask` mode, and doesn't run in the other modes.
 - **Options:** `model`, `context`, `permission_mode`, `allowed_tools`, `max_steps`, `think`,
   `web`, `memory`, `mcp` and `sandbox`. Leave one out to use your
   [configuration](configuration.md).

{lcode_cli-0.24.0 → lcode_cli-0.26.0}/docs/bench.md

@@ -38,8 +38,10 @@ A model usually takes 4 to 12 minutes; each task stops after 5 minutes (`--timeo
 ### More tasks and features
 
 `--tasks find-concept` adds a task in a larger repository: 40 files of a small backend where the
-model has to find a function by what it does. It isn't in the default set, so results stay
-comparable with earlier versions. `--repo-map` gives the model the [repository map](search.md) and
+model has to find a function by what it does. `--tasks runtime-bug` adds a bug that shows only
+when the code runs: a camera wall's window grows taller with every video frame and can't be made
+smaller again. Reading the code suggests band-aids that fail the hidden test; running it shows the
+cause. Neither is in the default set, so results stay comparable with earlier versions. `--repo-map` gives the model the [repository map](search.md) and
 `--code-search` indexes each task's folder for [semantic search](search.md#semantic-code-search);
 both are off in `lcode bench` by default, for the same reason.
 

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

@@ -43,6 +43,7 @@ lcode config path                      # print the file location
 | `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 |
+| `secret_check` | `true` | Before `git commit` and `git push`, look for passwords, keys and tokens they'd add ([details](usage.md#secrets-in-commits)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Besides these settings, `config.toml` can hold [hooks](hooks.md) (`[[hooks]]`) and

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

@@ -29,6 +29,19 @@ 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).
 
+### Checking its own work
+
+Small models like to call work done after a syntax check. The system prompt tells the model what
+counts as checked:
+
+- run what it changed the way it will be used;
+- reproduce a bug before fixing it, then show it's gone;
+- check what it can't see (a GUI, a web page, a layout) without a screen: Qt's `offscreen`
+  platform, a headless browser, or a script that prints sizes or renders an image it then looks
+  at;
+- never mark a task done or call something tested without having run it, and tell you what to
+  look at when it couldn't check.
+
 ### 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

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

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

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

@@ -213,6 +213,39 @@ deny lists, per user or per repository; deny always wins, even in `yolo`. Text a
 With the [sandbox](sandbox.md) on, `auto-edit` mode runs shell commands without asking too: they can
 only reach the project, and `/undo` can take their changes back.
 
+### Secrets in commits
+
+Before the model runs `git commit` or `git push`, lcode checks what would go into the repository's
+history: the lines a commit adds (including files a `git add` in the same command stages), or every
+commit a push would send. It looks for:
+
+- passwords, keys and tokens written as values in code or configuration, like
+  `"password": "…"` or `API_KEY=…`;
+- credentials in addresses, like `rtsp://admin:…@192.168.1.10`;
+- private keys and tokens with a known form (GitHub, GitLab, AWS, Slack, OpenAI, Anthropic, xAI,
+  Google, Hugging Face, Stripe);
+- `.env` files.
+
+Placeholders such as `CHANGE_ME`, `your_password`, `${PASSWORD}` or `os.environ["PASSWORD"]` don't
+count.
+
+```text
+This commit would add what looks like a secret to the repository's history:
+- camera_wall.py:42: a password or key: "password": "Xk…"
+```
+
+- **In `ask` mode,** you decide: lcode shows the findings and the command.
+- **In `auto-edit` and `yolo`,** the command doesn't run. The model is told to read the secret from
+  an environment variable or a configuration file that git ignores, and to ask you if it isn't one.
+- **`/commit` and `/pr`** show the same findings before you confirm.
+- **The [GitHub Action](automation.md#github-action)** doesn't commit or push at all when it finds
+  one.
+
+If a line only looks like a secret, add `lcode: allow-secret` (or `gitleaks:allow`) in a comment
+on it. `lcode config set secret_check false` turns the check off. It's a safety net, not a full
+scanner: for a public repository, also run a tool such as [gitleaks](https://github.com/gitleaks/gitleaks)
+before you push.
+
 ## Plan mode
 
 Local models are slower than cloud models and make more mistakes, so on a bigger change it pays to

{lcode_cli-0.24.0 → lcode_cli-0.26.0}/pyproject.toml

@@ -82,6 +82,7 @@ ignore = [
 "src/lcode/context.py" = ["E501"]
 "src/lcode/lsp.py" = ["E501"]
 "src/lcode/repomap.py" = ["E501"]
+"src/lcode/bench_runtime.py" = ["E501"] # the task's files and hidden test
 "src/lcode/codesearch.py" = ["E501"]
 "src/lcode/bench_backend.py" = ["E501"]
 "src/lcode/backends.py" = ["E501"]

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

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

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

@@ -302,7 +302,14 @@ def answer(hub: GitHub, task: Task, inputs: Inputs, cwd: Path) -> None:
         reply = result.text.strip() or "(no answer)"
         changed = git(cwd, "status", "--porcelain").strip()
         if changed:
-            from lcode import gitflow
+            from lcode import gitflow, secretscan
+
+            found = secretscan.in_files(cwd, ["."], staged=False)
+            if found:
+                raise ActionError(
+                    secretscan.report("commit", found, excerpts=False) + "\n\nSo lcode didn't commit or push its "
+                    "changes. Secrets belong in the repository's secrets or in configuration that git ignores."
+                )
 
             data = gitflow.ask(
                 session.agent,

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

@@ -81,14 +81,18 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 - Use your tools to gather facts. Never guess file contents, APIs, or command output — read, search, or run them.
 - To understand a repository: look at the layout, README/docs, entry points and config, then grep and read the relevant files. Cite code as `path:line`.
 - Read a file before editing it. Use edit_file for targeted changes and write_file for new files or full rewrites. old_string must be copied exactly from the file (without the line-number prefixes).
-- After writing or changing code, verify it: run the script, the tests, or at least a syntax check (e.g. `{python} -m py_compile file.py`). Fix what fails.
 - Match the existing code style, naming and structure. Don't add unrequested features.
 - For multi-step tasks, plan with todo_write and keep it updated.
 - Work autonomously until the task is done. Only stop to ask the user when you are genuinely blocked or the decision is theirs.
 - Don't run destructive or irreversible commands (rm -rf, git reset --hard, git push --force, dropping data) unless the user explicitly asked.
-- Never claim something works without having run it. If something fails, say so and show the relevant error.
 - If the user denies a tool call, don't retry the same thing; adjust or ask.
 
+# Verifying your work
+- A syntax check or an import only shows that code loads. Run what you changed the way it will be used (the script, the tests, the app) and fix what fails.
+- To fix a bug, first reproduce each problem the user reports with a test, a command or a short script, then run the same checks to show they're gone.
+- For what you can't see, like a GUI, a web page or a layout, check it without a screen where you can: `QT_QPA_PLATFORM=offscreen` for Qt, a headless browser, or a script that prints sizes and positions or renders to an image{look}. Measure instead of assuming.
+- Never claim something works, mark a todo done, or call it tested unless you ran it. If you couldn't check something, say so and tell the user exactly what to look for. If something fails, say so and show the relevant error.
+
 # Communication
 - Be concise and direct; no filler. Use GitHub-flavored markdown.
 - When you finish, give a short summary of what you found or changed and anything the user needs to do.
@@ -229,6 +233,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
+    secret_check: bool = True  # scan what git commit and git push would add (lcode.secretscan)
     repeat_limit: int = 3  # identical calls with identical results before the model is told (lcode.repeats)
 
 
@@ -317,6 +322,7 @@ class Agent:
             skills=extensions.skills_prompt(self.extensions().skills, self.settings.context),
             code=self.code_prompt(),
             map=self.map_prompt(),
+            look=" you look at with view_image" if self.vision_model() else "",
         )
 
     def repo_map(self) -> repomap.RepoMap | None:

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

@@ -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"],
+        secret_check=cfg["secret_check"],
         repeat_limit=cfg["repeat_limit"],
     )
     agent = Agent(ollama, settings, cwd, console=console)

{lcode_cli-0.24.0 → lcode_cli-0.26.0}/src/lcode/bench.py

@@ -746,7 +746,7 @@ TASKS = [
 
 def extra_tasks() -> list[Task]:
     """Tasks that only run when asked for with --tasks (they're slower, or test optional features)."""
-    from lcode import bench_backend
+    from lcode import bench_backend, bench_runtime
 
     return [
         Task(
@@ -755,7 +755,14 @@ def extra_tasks() -> list[Task]:
             bench_backend.PROMPT,
             bench_backend.FILES,
             bench_backend.check,
-        )
+        ),
+        Task(
+            "runtime-bug",
+            "Fix a bug that shows only when it runs",
+            bench_runtime.PROMPT,
+            bench_runtime.FILES,
+            bench_runtime.check,
+        ),
     ]
 
 

lcode_cli-0.26.0/src/lcode/bench_runtime.py

@@ -0,0 +1,156 @@
+"""A bug that only shows when the code runs, for `lcode bench --tasks runtime-bug`.
+
+A camera wall lays out video panels in a window. While video plays, the window grows taller frame after
+frame, past the screen, and can't be made smaller again: each panel's minimum size is taken from the
+frame it shows, and the frame is scaled to the whole cell, status bar included. Reading the code, the
+obvious fixes are band-aids (ignore the minimum sizes, or only fix the scaling) that fail part of the
+hidden test. Running it, the window sizes show the ratchet. It's the kind of bug a GUI has, without
+needing one, and rewards reproducing a problem before fixing it.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+WALL = '''\
+"""A camera wall: a window with a grid of panels, each showing its camera's latest video frame."""
+
+SPACING = 8  # pixels between and around the panels
+STATUS_BAR = 20  # under its video, each panel shows the camera's name and status
+
+
+class Panel:
+    def __init__(self, name):
+        self.name = name
+        self.min_width = self.min_height = 1  # the panel can't get smaller than this
+        self.video = (0, 0)  # the size of the frame on screen
+
+    def show(self, frame_width, frame_height, cell_width, cell_height):
+        """Show a frame scaled to fit the panel's cell, keeping its aspect ratio."""
+        scale = min(cell_width / frame_width, cell_height / frame_height)
+        self.video = (int(frame_width * scale), int(frame_height * scale))
+        # The video and the status bar under it must stay visible.
+        self.min_width, self.min_height = self.video[0], self.video[1] + STATUS_BAR
+
+
+class Wall:
+    def __init__(self, names, rows, cols):
+        self.rows, self.cols = rows, cols
+        self.panels = [Panel(name) for name in names]
+        self.width = self.height = 0
+
+    def resize(self, width, height):
+        """Ask for a window size. The window can't be smaller than its panels need."""
+        need_width = max(p.min_width for p in self.panels) * self.cols + SPACING * (self.cols + 1)
+        need_height = max(p.min_height for p in self.panels) * self.rows + SPACING * (self.rows + 1)
+        self.width, self.height = max(width, need_width), max(height, need_height)
+
+    def cell(self):
+        """The size of one panel's cell."""
+        return (
+            (self.width - SPACING * (self.cols + 1)) // self.cols,
+            (self.height - SPACING * (self.rows + 1)) // self.rows,
+        )
+
+    def new_frame(self, frame_width, frame_height):
+        """Every camera delivered a frame: show it in each panel, then let the layout settle."""
+        cell_width, cell_height = self.cell()
+        for panel in self.panels:
+            panel.show(frame_width, frame_height, cell_width, cell_height)
+        self.resize(self.width, self.height)
+'''
+
+SIMULATE = '''\
+"""Play the camera wall without a screen: python simulate.py [WIDTH HEIGHT [ROWSxCOLS]]"""
+
+import sys
+
+from wall import Wall
+
+
+def main():
+    width, height = (int(sys.argv[1]), int(sys.argv[2])) if len(sys.argv) > 2 else (2560, 1080)
+    rows, cols = map(int, sys.argv[3].split("x")) if len(sys.argv) > 3 else (3, 3)
+    wall = Wall([f"camera {n + 1}" for n in range(rows * cols)], rows, cols)
+    wall.resize(width * 9 // 10, height * 9 // 10)
+    print(f"{rows}x{cols} wall on a {width}x{height} screen, window {wall.width}x{wall.height}")
+    for n in range(1, 6):
+        wall.new_frame(1920, 1080)
+        print(f"after frame {n}: window {wall.width}x{wall.height}, video {wall.panels[0].video}")
+
+
+if __name__ == "__main__":
+    main()
+'''
+
+FILES = {"wall.py": WALL, "simulate.py": SIMULATE}
+
+PROMPT = (
+    "Users say the camera wall in wall.py keeps growing taller while video plays, until it's bigger than "
+    "their screen, and after that it can't be made smaller again. Fix it."
+)
+
+HIDDEN_TEST = """\
+import unittest
+
+from wall import SPACING, STATUS_BAR, Wall
+
+SCREENS = [(2560, 1080, 3, 3), (1920, 1080, 2, 3), (1366, 768, 3, 3), (3440, 1440, 2, 4), (1280, 1024, 2, 2)]
+
+
+def play(width, height, rows, cols, frames=30, frame=(1920, 1080)):
+    wall = Wall([f"camera {n}" for n in range(rows * cols)], rows, cols)
+    wall.resize(width, height)
+    for _ in range(frames):
+        wall.new_frame(*frame)
+    return wall
+
+
+class HiddenTest(unittest.TestCase):
+    def test_keeps_its_size(self):
+        for width, height, rows, cols in SCREENS:
+            with self.subTest(screen=(width, height), grid=(rows, cols)):
+                wall = play(width * 9 // 10, height * 9 // 10, rows, cols)
+                self.assertEqual((wall.width, wall.height), (width * 9 // 10, height * 9 // 10))
+
+    def test_can_be_made_smaller(self):
+        wall = play(2304, 972, 3, 3)
+        wall.resize(1280, 720)
+        wall.new_frame(1920, 1080)
+        self.assertEqual((wall.width, wall.height), (1280, 720))
+
+    def test_video_fits_and_fills_its_cell(self):
+        for width, height, rows, cols in SCREENS:
+            for frame in [(1920, 1080), (1280, 960), (720, 1280)]:
+                with self.subTest(screen=(width, height), grid=(rows, cols), frame=frame):
+                    wall = play(width * 9 // 10, height * 9 // 10, rows, cols, frames=3, frame=frame)
+                    cell_width = (wall.width - SPACING * (cols + 1)) // cols
+                    cell_height = (wall.height - SPACING * (rows + 1)) // rows
+                    for panel in wall.panels:
+                        video_width, video_height = panel.video
+                        self.assertLessEqual(video_width, cell_width)
+                        self.assertLessEqual(video_height + STATUS_BAR, cell_height)
+                        fills = video_width >= cell_width - 2 or video_height + STATUS_BAR >= cell_height - 2
+                        self.assertTrue(fills, "the video doesn't use the room it has")
+                        self.assertAlmostEqual(video_width / video_height, frame[0] / frame[1], delta=0.02)
+"""
+
+PROBLEMS = {
+    "test_keeps_its_size": "the window still grows",
+    "test_can_be_made_smaller": "the window can't be made smaller",
+    "test_video_fits_and_fills_its_cell": "the video doesn't fit its cell above the status bar (or doesn't fill it)",
+}
+
+
+def check(folder: Path, answer: str):
+    from lcode.bench import Check, last_line, run_python
+
+    if not (folder / "wall.py").is_file():
+        return Check(False, "wall.py is missing")
+    (folder / "test_hidden_wall.py").write_text(HIDDEN_TEST)
+    r = run_python(folder, "-m", "unittest", "-q", "test_hidden_wall")
+    if r.returncode == 0:
+        return Check(True, "keeps its size, can be made smaller, and the video fits")
+    failed = [text for name, text in PROBLEMS.items() if re.search(rf"\b{name}\b", r.stderr)]
+    return Check(False, "; ".join(failed) or last_line(r.stderr) or last_line(r.stdout))

{lcode_cli-0.24.0 → lcode_cli-0.26.0}/src/lcode/config.py

@@ -60,6 +60,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "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)"),
+    "secret_check": (True, bool, "before git commit and git push, look for passwords, keys and tokens they'd add"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {

{lcode_cli-0.24.0 → lcode_cli-0.26.0}/src/lcode/gitflow.py

@@ -24,6 +24,7 @@ from typing import TYPE_CHECKING
 
 from rich.markup import escape
 from rich.panel import Panel
+from rich.text import Text
 
 if TYPE_CHECKING:
     from lcode.agent import Agent
@@ -316,6 +317,9 @@ def commit_command(agent: Agent, hint: str = "") -> None:
         chosen = [f for f in answer.get("files") or [] if f in paths]
         files = chosen or paths
     left_out = [p for p in paths if p not in files]
+    from lcode import secretscan
+
+    secrets_found = secretscan.in_files(root, files, bool(staged)) if agent.settings.secret_check else []
     while True:
         c.print(Panel(escape(message), title="Commit message", title_align="left", border_style="cyan"))
         c.print(f"  [bold]Files[/] {escape(', '.join(files))}")
@@ -323,6 +327,9 @@ def commit_command(agent: Agent, hint: str = "") -> None:
             c.print(f"  [dim]Left out (unrelated, the model thinks): {escape(', '.join(left_out))}[/]")
         if risky:
             c.print(f"  [dim]Left out (may hold secrets; stage them yourself if needed): {escape(', '.join(risky))}[/]")
+        if secrets_found:
+            c.print(Text(secretscan.report("commit", secrets_found), style="red"))
+            c.print("  [dim]Commit them only if they aren't secrets; otherwise move them out of the code first.[/]")
         choice = confirm(agent, "  [y] commit · [e] edit the message · [n] cancel: ", message)
         if choice == "e":
             from lcode.planning import edit_text
@@ -552,6 +559,14 @@ def pr_command(agent: Agent, arg: str = "") -> None:
 
 
 def push(agent: Agent, root: Path, remote: str, branch: str) -> bool:
+    from lcode import secretscan
+
+    found = secretscan.outgoing(root, branch) if agent.settings.secret_check else []
+    if found:
+        agent.console.print(Text(secretscan.report("push", found), style="red"))
+        if confirm(agent, "  Push anyway? [y]es / [n]o: ") != "y":
+            agent.console.print("Not pushed.")
+            return False
     try:
         with agent.console.status(f"Pushing {escape(branch)}…", spinner="dots"):
             git(root, "push", "-q", "-u", remote, branch, timeout=300)