lcode-cli 0.25.0__tar.gz → 0.27.0__tar.gz

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/CHANGELOG.md

@@ -6,6 +6,41 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.27.0] - 2026-10-10
+
+### Changed
+
+- Long sessions are summarized earlier: once the conversation reaches 64K tokens (`compact_at`),
+  even when the window is larger. Before, a 256K window was summarized only at about 220K, far past
+  where small models work well. lcode still removes old tool output first, and summarizes only if
+  that's not enough. `lcode config set compact_at 0` keeps only the 85% rule, and
+  `lcode bench --compact-at` compares ceilings. Measured with qwen3.6-35b: making room earlier
+  doesn't cost tasks (21 of 24 either way) and saved 17% of the time. See
+  [Context management](https://nasser1941.github.io/lcode/how-it-works/#context-management).
+- Summaries keep your latest requests (up to eight) word for word, so the goal survives the
+  retelling. `/context` shows where the session makes room.
+
+### Fixed
+
+- After lcode removed an earlier file read to make room, the model sometimes answered questions
+  about that file from memory, and got them wrong, instead of reading it again. The files whose
+  only copy went are now named next to the request it's working on, and the note in their place
+  says plainly that the content is gone. A conversation that was just summarized isn't summarized
+  again until it has grown by a quarter of `compact_at`, which must be at least 16K (or 0).
+
+## [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
@@ -540,7 +575,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.25.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.27.0...HEAD
+[0.27.0]: https://github.com/nasser1941/lcode/compare/v0.26.0...v0.27.0
+[0.26.0]: https://github.com/nasser1941/lcode/compare/v0.25.0...v0.26.0
 [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

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.25.0
+Version: 0.27.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.25.0 → lcode_cli-0.27.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.25.0 → lcode_cli-0.27.0}/docs/bench.md

@@ -51,7 +51,7 @@ Each task normally starts a new conversation. `--session` runs them all in **one
 instead, as a long working session would, so the context fills up and lcode's
 [context management](how-it-works.md#context-management) has to work: the summary shows how often
 it removed old tool output and how often it summarized the conversation. `--no-prune` turns the
-removal off, to compare.
+removal off, to compare, and `--compact-at` sets the ceiling (`--compact-at 0`: only at 85%).
 
 ```bash
 lcode bench --context 32k --session --rounds 3
@@ -74,6 +74,17 @@ at no measurable cost in tasks solved or time. The bench tasks are independent o
 which is where summaries hurt least; in a real session, where later requests build on earlier
 ones, keeping the conversation intact matters more.
 
+With a large window, `compact_at` decides when lcode makes room. In a 128K window, 24 tasks in one
+conversation reach about 40K tokens, so the default ceiling of 64K never comes into play. Making
+room earlier than needed doesn't cost tasks:
+
+| 128K window, 24 tasks | No room made (peak ~40K) | `--compact-at 32k` |
+|---|---|---|
+| Conversation summarized | 0 times | 1 time (old tool output removed once) |
+| Tasks solved | 21 of 24 | 21 of 24 |
+| Time | 33 min | 27.5 min |
+| Average prompt | 22.9K tokens | 16.6K tokens |
+
 ## The tasks
 
 Every task runs in a new temporary folder, with every permission granted (`yolo` mode) and web

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/docs/configuration.md

@@ -37,12 +37,14 @@ lcode config path                      # print the file location
 | `repo_map` | `true` | Give the model a ranked [map of the repository](search.md) |
 | `embed_model` | `auto` | Embedding model for [semantic code search](search.md#semantic-code-search): `auto`, `off` or a model name |
 | `lsp` | `auto` | Use installed [language servers](lsp.md) for code navigation and errors after edits: `auto` or `off` |
+| `compact_at` | `65536` | Make room (prune, then summarize) once the conversation reaches this many tokens, even in a larger window (at least 16K); `0` leaves only the 85% rule ([why](how-it-works.md#context-management)) |
 | `prune` | `true` | When the context is 85% full, first remove old tool output, and summarize the conversation only if that's not enough ([how](how-it-works.md#context-management)) |
 | `subagents` | `true` | Let the model hand tasks to [subagents](agents.md) with their own context |
 | `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 |
+| `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.25.0 → lcode_cli-0.27.0}/docs/how-it-works.md

@@ -73,21 +73,32 @@ in a temporary git worktree, and their changes come back as a diff.
 ## Context management
 
 Ollama keeps the processed conversation in its KV cache, so each turn only processes the new tokens.
-lcode tracks how full the window is from Ollama's token counts. Most of a long session's context is
-old tool output, so when the window is 85% full:
+lcode tracks how full the window is from Ollama's token counts. It makes room when the window is
+85% full, or when the conversation reaches 64K tokens (`compact_at`), whichever comes first.
+Small models lose track in long contexts well before a large window is full: in one long session,
+Qwen3.6 35B started repeating itself and overlooking what it had read once the conversation passed
+about 75K tokens. Most of a long session's
+context is old tool output, so:
 
 1. **lcode removes old tool output first.** File contents, command output and search results from
    before your last two requests become one-line notes that say what was there, such as
-   `[lcode: read src/app.py earlier; removed to save context. Read it again if you need it.]`.
+   `[lcode: read src/app.py earlier; its content was removed …. Read it again before answering anything about it.]`.
    An earlier copy of a file that was read again later goes too, even in recent requests. Subagent
-   reports, skill instructions and the approved plan stay.
-2. **If that brings the conversation under 70%,** the work simply continues: nothing is summarized,
+   reports, skill instructions and the approved plan stay. The files whose only copy went are also
+   named next to the request the model is working on, since models tend to overlook a note deep in
+   the conversation and answer from memory instead of reading the file again.
+2. **If that brings the conversation well under the limit** (70% of the window, or about 53K
+   tokens with `compact_at`), the work simply continues: nothing is summarized,
    and the conversation itself stays word for word.
    If it's not, lcode also removes the tool output of your previous request, keeping only the
    latest one's. (`lcode config set prune false` skips this step.)
 3. **Otherwise lcode summarizes.** It asks whether anything is worth [remembering](memory.md), since
    the summary leaves details out, then has the model write a summary of the conversation (goals,
-   findings, files changed, next steps) and continues from it.
+   findings, files changed, next steps) and continues from it. Your latest requests (up to eight)
+   are kept word for word under the summary, so the goal isn't lost in the retelling.
+
+`lcode config set compact_at 128k` moves the ceiling, and `0` turns it off, leaving only the 85%
+rule. `/context` shows where the current session makes room.
 
 Long tool output (over 30,000 characters) keeps its beginning, its end and the lines in between
 that look like errors. The full output is saved under `~/.local/state/lcode/outputs/` (for a week)

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/docs/quickstart.md

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

{lcode_cli-0.25.0 → lcode_cli-0.27.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.25.0 → lcode_cli-0.27.0}/src/lcode/__init__.py

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

{lcode_cli-0.25.0 → lcode_cli-0.27.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.25.0 → lcode_cli-0.27.0}/src/lcode/agent.py

@@ -233,6 +233,8 @@ 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)
+    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)
 
 
@@ -269,6 +271,7 @@ class Agent:
         self.agent_runs: list[subagents.Record] = []  # subagents run in this session, for /agents
         self.plan = ""  # the plan the user approved; kept through compaction
         self.pruned = self.compacted = 0  # how often the context was pruned or summarized automatically
+        self.summarized_size = 0  # tokens right after the last summary (0: none in this conversation)
         self._extensions: tuple[Path, extensions.Extensions] | None = None
         self.skills_loaded: set[str] = set()  # skills whose instructions are in the conversation
         # Set on subagents (see lcode.subagents):
@@ -513,6 +516,7 @@ class Agent:
         return WEB_PROMPT.format(tools=tools, date=dt.date.today().isoformat())
 
     def reset(self) -> None:
+        self.summarized_size = 0
         self.messages = [{"role": "system", "content": self.system_prompt()}]
         self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
@@ -1045,13 +1049,27 @@ class Agent:
         return text + ("\n\n" + "\n\n".join(attached) if attached else "")
 
     # -- context management
+    def compact_limit(self) -> int:
+        """The tokens in use at which lcode makes room: 85% of the window, or `compact_at` when that's lower.
+        Small models lose track in long contexts well before a large window is full."""
+        limit = int(AUTO_COMPACT_RATIO * self.settings.context)
+        if self.settings.compact_at > 0:
+            limit = min(limit, self.settings.compact_at)
+        return limit
+
     def maybe_compact(self) -> None:
-        if self.ctx_used <= AUTO_COMPACT_RATIO * self.settings.context:
+        limit = self.compact_limit()
+        if self.ctx_used <= limit:
             return
+        enough = int(limit * PRUNED_ENOUGH / AUTO_COMPACT_RATIO)  # after pruning, a summary isn't needed below this
         if self.settings.prune:
-            saved = context_tools.prune(self.messages)  # tool output from before the last two requests
-            if self.ctx_used - saved // 3 > PRUNED_ENOUGH * self.settings.context:
-                saved += context_tools.prune(self.messages, keep=1)  # not enough: before the last request
+            removed: list[str] = []  # files and pages whose only copy goes
+            saved = context_tools.prune(self.messages, removed=removed)  # tool output from before the last two requests
+            if self.ctx_used - saved // 3 > enough:
+                saved += context_tools.prune(
+                    self.messages, keep=1, removed=removed
+                )  # not enough: before the last request
+            context_tools.note_removed(self.messages, removed)
             if saved:
                 self.pruned += 1
                 self.ctx_used = max(len(self.messages[0]["content"]) // 3, self.ctx_used - saved // 3)
@@ -1059,9 +1077,17 @@ class Agent:
                     f"[dim]Removed old tool output from the conversation (~{format_tokens(saved // 3)} tokens) to "
                     "make room.[/]"
                 )
-                if self.ctx_used <= PRUNED_ENOUGH * self.settings.context:
+                if self.ctx_used <= enough:
                     return
-        self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
+        window_full = self.ctx_used > AUTO_COMPACT_RATIO * self.settings.context
+        if not window_full and self.summarized_size and self.ctx_used - self.summarized_size < limit // 4:
+            return  # summarized not long ago: summarizing again so soon would only lose more
+        if limit < AUTO_COMPACT_RATIO * self.settings.context:
+            self.console.print(
+                f"[yellow]The conversation reached {format_tokens(limit)} tokens (compact_at) — summarizing it…[/]"
+            )
+        else:
+            self.console.print("[yellow]Context is nearly full — compacting the conversation…[/]")
         self.compacted += 1
         self.compact()
 
@@ -1082,9 +1108,13 @@ class Agent:
         with self.console.status("[cyan]Compacting…[/]"):
             for chunk in self.chat([*self.messages, {"role": "user", "content": instructions}], None, False):
                 summary += chunk.get("message", {}).get("content", "")
+        requests = context_tools.user_requests(self.messages)
         self.messages = [
             {"role": "system", "content": self.system_prompt()},
-            {"role": "user", "content": f"[Summary of our conversation so far]\n\n{summary}"},
+            {
+                "role": "user",
+                "content": f"{sessions.SUMMARY_PREFIX}\n\n{summary}" + context_tools.requests_block(requests),
+            },
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]
         if self.plan:  # the approved plan stays word for word
@@ -1096,6 +1126,7 @@ class Agent:
             )
             self.skills_loaded.clear()
         self.ctx_used = sum(len(m["content"]) for m in self.messages) // 3
+        self.summarized_size = self.ctx_used
         self.reflected = len(self.messages)
         self.console.print(Panel(Markdown(summary), title="Compacted summary", border_style="blue"))
 

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/src/lcode/api.py

@@ -194,7 +194,9 @@ 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"],
+        compact_at=cfg["compact_at"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
     agent.interactive = options.interactive

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/src/lcode/cli.py

@@ -579,6 +579,7 @@ def cmd_bench(args) -> None:
             web="off",
             checkpoints=False,
             prune=not args.no_prune,
+            compact_at=cfg["compact_at"] if args.compact_at is None else args.compact_at,
             repo_map=args.repo_map,
             embed_model=cfg["embed_model"] if args.code_search else "off",
         )
@@ -678,6 +679,14 @@ def cmd_chat(args) -> None:
         sys.exit(exit_code)
 
 
+def compact_tokens(value: str) -> int:
+    """`--compact-at`: a token count such as 64k, or 0."""
+    try:
+        return config.parse_compact_at(value)
+    except ConfigError as e:
+        raise argparse.ArgumentTypeError(str(e)) from e
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="lcode",
@@ -765,6 +774,12 @@ 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(
+        "--compact-at",
+        type=compact_tokens,
+        metavar="TOKENS",
+        help="summarize at this many tokens, e.g. 64k (default: the compact_at setting; 0: only at 85%%)",
+    )
     subs["bench"] = p
     p = argparse.ArgumentParser(
         prog="lcode index",

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/src/lcode/config.py

@@ -60,6 +60,8 @@ 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"),
+    "compact_at": (65536, int, "summarize at this many tokens even when the window is larger (0: only at 85%)"),
     "max_parallel_agents": (1, int, "subagents that may run at the same time (more needs OLLAMA_NUM_PARALLEL)"),
 }
 ENV_OVERRIDES = {
@@ -80,6 +82,19 @@ class ConfigError(ValueError):
     pass
 
 
+MIN_COMPACT_AT = 16384  # below this, the system prompt and a summary alone come close to the ceiling
+
+
+def parse_compact_at(value: str | int) -> int:
+    """compact_at: a token count like parse_context's, at least 16K, or 0 (off)."""
+    if str(value).strip().lower() in ("0", "off", "false", "none"):
+        return 0
+    tokens = parse_context(value)
+    if tokens < MIN_COMPACT_AT:
+        raise ConfigError(f"compact_at {tokens} is too small: use at least 16k, or 0 to turn it off")
+    return tokens
+
+
 def parse_context(value: str | int) -> int:
     """Parse '131072', '128k', '128K' or '1m' into a token count (k = 1024)."""
     if isinstance(value, int):
@@ -117,6 +132,8 @@ def coerce(key: str, value: object) -> object:
     _, typ, _ = SETTINGS[key]
     if key == "context":
         return parse_context(value)  # type: ignore[arg-type]
+    if key == "compact_at":
+        return parse_compact_at(value)  # type: ignore[arg-type]
     if key in ("ollama_host", "searxng_url"):
         return normalize_host(str(value))
     if key == "base_url":

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/src/lcode/context.py

@@ -29,6 +29,10 @@ if TYPE_CHECKING:
 KEEP_RECENT_REQUESTS = 2  # tool results of the last requests stay as they are
 MIN_PRUNE_CHARS = 400  # shorter results aren't worth replacing
 PRUNED = "[lcode: "  # how stubs start, so they're never pruned twice
+GONE = (  # a removed file read: firm, because models answer from the stub instead of reading it again
+    "earlier; its content was removed to save context and isn't in this conversation any more. Read it again "
+    "before answering anything about it.]"
+)
 KEEP_TOOLS = {"agent", "skill", "memory", "todo_write", "present_plan"}  # short, or still guiding the work
 ERROR_LINE = re.compile(
     r"error|exception|traceback|failed|failure|fatal|panic|assert|denied|not found|cannot|can't|undefined", re.I
@@ -37,6 +41,56 @@ MAX_ERROR_LINES = 40
 OUTPUT_DAYS = 7  # saved full outputs are deleted after this
 
 
+# ----------------------------------------------------------------------------- the user's requests
+
+REQUESTS_HEADER = "[The user's requests in this conversation, word for word, oldest first]"
+MAX_REQUESTS = 8  # the most recent ones are kept through a summary
+MAX_REQUEST_CHARS = 1500
+# What lcode appends to the user's words: attached files, images and folders, and its own notes.
+ATTACHED = re.compile(r"\n\n(?:<file path=|<image path=|<directory path=|\[lcode[:\]] |\[The user wants the )")
+
+
+def request_text(content: str) -> str:
+    """The user's own words in a message, without what lcode attached to it."""
+    cut = ATTACHED.search(content)
+    return (content[: cut.start()] if cut else content).strip()
+
+
+def user_requests(messages: list[dict]) -> list[str]:
+    """What the user asked in the conversation, oldest first, including the requests an earlier summary kept."""
+    requests: list[str] = []
+    for message in messages:
+        content = message.get("content") or ""
+        if message.get("role") != "user":
+            continue
+        if content.startswith(SUMMARY_PREFIX):
+            start = content.find(REQUESTS_HEADER)
+            if start >= 0:
+                rest = content[start + len(REQUESTS_HEADER) :]
+                try:
+                    kept, _ = json.JSONDecoder().raw_decode(rest[rest.index("[") :])
+                    requests += [str(r) for r in kept]
+                except ValueError:
+                    pass
+            continue
+        if content.startswith("[lcode]"):
+            continue  # lcode's own nudges
+        text = request_text(content)
+        if text:
+            requests.append(text)
+    return requests
+
+
+def requests_block(requests: list[str]) -> str:
+    """The user's latest requests, word for word, to keep the goal through a summary."""
+    if not requests:
+        return ""
+    kept = [r if len(r) <= MAX_REQUEST_CHARS else f"{r[: MAX_REQUEST_CHARS - 200]} […] {r[-150:]}" for r in requests]
+    older = len(kept) - MAX_REQUESTS
+    note = f" (and {older} earlier, in the summary)" if older > 0 else ""
+    return f"\n\n{REQUESTS_HEADER}{note}\n{json.dumps(kept[-MAX_REQUESTS:], ensure_ascii=False, indent=1)}"
+
+
 # ----------------------------------------------------------------------------- pruning
 
 
@@ -63,7 +117,7 @@ def stub(name: str, args: dict, content: str) -> str:
         if args.get("offset") or args.get("limit"):
             start = int(args.get("offset") or 1)
             span = f" from line {start}"
-        return f"{PRUNED}read {args.get('path', 'a file')}{span} earlier; removed to save context. Read it again if you need it.]"
+        return f"{PRUNED}read {args.get('path', 'a file')}{span} {GONE}"
     if name == "bash":
         command = " ".join(str(args.get("command", "")).split())
         command = command if len(command) <= 80 else command[:79] + "…"
@@ -92,8 +146,9 @@ def boundary(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
     return requests[-keep] if len(requests) >= keep else 0
 
 
-def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
-    """Replace stale tool results with stubs, in place. Returns the number of characters saved."""
+def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS, removed: list[str] | None = None) -> int:
+    """Replace stale tool results with stubs, in place. Returns the number of characters saved; the files and
+    pages whose only copy went are added to `removed`."""
     calls = calls_for_results(messages)
     edge = boundary(messages, keep)
     # A read is superseded by a later read of the whole file, or of the same lines: not by a later
@@ -118,12 +173,34 @@ def prune(messages: list[dict], keep: int = KEEP_RECENT_REQUESTS) -> int:
             continue
         new = stub(name, args, content)
         if reread:
-            new = new.replace("earlier; removed", "earlier (read again later); removed")
+            new = new.replace(
+                GONE, "earlier (read again later); removed to save context. Read it again if you need it.]"
+            )
+        elif removed is not None and name in ("read_file", "web_fetch"):
+            what = str(args.get("path") or args.get("url") or "")
+            if what and what not in removed:
+                removed.append(what)
         messages[i]["content"] = new
         saved += len(content) - len(new)
     return saved
 
 
+def note_removed(messages: list[dict], removed: list[str]) -> None:
+    """Tell the model, next to the request it's working on, which files it no longer has: a stub deep in the
+    conversation is easy to overlook, and models then answer from memory instead of reading again."""
+    if not removed:
+        return
+    for message in reversed(messages):
+        content = str(message.get("content", ""))
+        if message.get("role") == "user" and not content.startswith(("[lcode]", SUMMARY_PREFIX)):
+            names = ", ".join(removed[:10]) + (f" and {len(removed) - 10} more" if len(removed) > 10 else "")
+            message["content"] = (
+                f"{content}\n\n[lcode] To make room, lcode removed what you read earlier from: {names}. It isn't in "
+                "this conversation any more: read it again before answering anything about it, don't answer from memory."
+            )
+            return
+
+
 # ----------------------------------------------------------------------------- long output
 
 

{lcode_cli-0.25.0 → lcode_cli-0.27.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)

{lcode_cli-0.25.0 → lcode_cli-0.27.0}/src/lcode/repl.py

@@ -242,7 +242,8 @@ def context_command(agent: Agent, arg: str, hardware: Hardware) -> None:
     c.print(
         f"In use: {format_tokens(agent.ctx_used)} of {format_tokens(s.context)} tokens "
         f"({100 * agent.ctx_used / s.context:.0f}%) in {len(agent.messages)} message"
-        f"{'' if len(agent.messages) == 1 else 's'}; auto-compacts at 85%."
+        f"{'' if len(agent.messages) == 1 else 's'}; makes room at {format_tokens(agent.compact_limit())} "
+        + ("(compact_at)." if agent.compact_limit() < AUTO_COMPACT_RATIO * s.context else "(85%).")
     )
     if agent.mcp and agent.mcp.ready():
         how = "found on demand" if agent.mcp.searching(s.context) else "sent with every request"