lcode-cli 0.6.1__tar.gz → 0.7.0__tar.gz

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/CHANGELOG.md

@@ -6,6 +6,20 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.7.0] - 2026-10-05
+
+### Added
+
+- Memory across sessions: lcode keeps short notes that later sessions load, only key knowledge and
+  not whole conversations. The model saves them with its new `memory` tool (and updates or deletes
+  them), you add them with `/remember`, and when a session ends (on quit, `/clear` or before
+  compaction) one quick question asks the model what from it is worth remembering. Notes are
+  per repository, shared by its git worktrees, plus a few for every repository; they're plain
+  markdown files, managed with `/memory`. The index in the system prompt is capped at about 2,000
+  tokens. Notes that look like they contain secrets are never saved. The `memory` setting is `ask`
+  (confirm each note, the default), `auto` or `off`; `--no-memory` turns it off for a session.
+  See [Memory](https://nasser1941.github.io/lcode/memory/).
+
 ## [0.6.1] - 2026-10-01
 
 ### Fixed
@@ -211,7 +225,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.6.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.7.0...HEAD
+[0.7.0]: https://github.com/nasser1941/lcode/compare/v0.6.1...v0.7.0
 [0.6.1]: https://github.com/nasser1941/lcode/compare/v0.6.0...v0.6.1
 [0.6.0]: https://github.com/nasser1941/lcode/compare/v0.5.0...v0.6.0
 [0.5.0]: https://github.com/nasser1941/lcode/compare/v0.4.1...v0.5.0

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.6.1
+Version: 0.7.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/
@@ -82,6 +82,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   Podman) that only sees your project, without network access unless you allow it.
 - **Undo.** lcode saves a checkpoint before the model changes files; `/undo` takes back the last
   request's edits, new files and shell-command changes, without touching your git history.
+- **Remembers what matters.** Corrections, decisions and where things live carry over to the next
+  session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
+  of a session. Not whole conversations, and never secrets.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -189,6 +192,10 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
+- [Parallel subagents](https://github.com/nasser1941/lcode/issues/40) with their own context
+- [Plan mode](https://github.com/nasser1941/lcode/issues/41) and [custom commands and skills](https://github.com/nasser1941/lcode/issues/42)
+- [Ready-made MCP for Metabase, Encord and Valohai](https://github.com/nasser1941/lcode/issues/53)
+- Then: [smarter context for small windows](https://github.com/nasser1941/lcode/issues/46), [language servers](https://github.com/nasser1941/lcode/issues/44), [a repository map with local embeddings](https://github.com/nasser1941/lcode/issues/45), [hooks](https://github.com/nasser1941/lcode/issues/43)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/README.md

@@ -48,6 +48,9 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   Podman) that only sees your project, without network access unless you allow it.
 - **Undo.** lcode saves a checkpoint before the model changes files; `/undo` takes back the last
   request's edits, new files and shell-command changes, without touching your git history.
+- **Remembers what matters.** Corrections, decisions and where things live carry over to the next
+  session as short notes, saved by the model, by you (`/remember`) or by a quick check at the end
+  of a session. Not whole conversations, and never secrets.
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
@@ -155,6 +158,10 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
+- [Parallel subagents](https://github.com/nasser1941/lcode/issues/40) with their own context
+- [Plan mode](https://github.com/nasser1941/lcode/issues/41) and [custom commands and skills](https://github.com/nasser1941/lcode/issues/42)
+- [Ready-made MCP for Metabase, Encord and Valohai](https://github.com/nasser1941/lcode/issues/53)
+- Then: [smarter context for small windows](https://github.com/nasser1941/lcode/issues/46), [language servers](https://github.com/nasser1941/lcode/issues/44), [a repository map with local embeddings](https://github.com/nasser1941/lcode/issues/45), [hooks](https://github.com/nasser1941/lcode/issues/43)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/docs/configuration.md

@@ -30,6 +30,7 @@ lcode config path                      # print the file location
 | `sandbox_network` | `false` | Let commands in the sandbox use the network |
 | `vision_model` | `auto` | The model that [looks at images](usage.md#images): `auto`, `off` or an Ollama model that can see |
 | `mcp_tools` | `auto` | How [MCP](mcp.md#context) tool definitions reach the model: `auto`, `direct` or `search` (on demand) |
+| `memory` | `ask` | [Notes that carry over](memory.md) to later sessions: `ask` (confirm each), `auto` or `off` |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Example file:
@@ -55,6 +56,7 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `OLLAMA_HOST` | `ollama_host` (same variable the Ollama CLI uses) |
 | `LCODE_WEB` | `web` |
 | `LCODE_SANDBOX` | `sandbox` |
+| `LCODE_MEMORY` | `memory` |
 | `OLLAMA_API_KEY`, `BRAVE_API_KEY`, `TAVILY_API_KEY` | API key for that [search provider](usage.md#web-search) (never stored in the config file) |
 | `LCODE_HOME` | where sessions and prompt history are stored |
 
@@ -69,6 +71,7 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `~/.local/state/lcode/mcp-auth/` | Sign-in tokens for remote MCP servers (readable only by you) |
 | `~/.local/state/lcode/mcp-logs/` | Error output of local MCP servers |
 | `~/.local/state/lcode/checkpoints/` | Checkpoints for `/undo` (copies of your project's files; deleted after 14 days) |
+| `~/.local/state/lcode/memory/` | [Memory](memory.md) notes: `user/` for every repository, `projects/<repository>/` for each one |
 | `~/.local/state/lcode/limits.json` | Context sizes that ran out of GPU memory on this machine (safe to delete) |
 
 Sessions contain everything the model read, including file contents. Delete the folder to clear them.

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/docs/how-it-works.md

@@ -18,7 +18,7 @@ flowchart LR
 ## The agent loop
 
 1. Your message goes to the model along with a system prompt (environment, repository layout,
-   `AGENTS.md`) and the JSON schemas of the tools.
+   `AGENTS.md`, the index of [memory notes](memory.md)) and the JSON schemas of the tools.
 2. The response streams back. Reasoning shows as a spinner (or text with `--show-thinking`); the
    answer is rendered as markdown, block by block.
 3. If the model called tools, lcode runs them, asking for permission where needed, and appends the
@@ -34,8 +34,9 @@ didn't match).
 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. At 85% it asks the model to write a
 summary of the conversation (goals, findings, files changed, next steps) and continues from that
-summary. Tool outputs are capped at 30,000 characters (head and tail kept) so one noisy command
-can't flood the window.
+summary. Just before that, it asks whether anything from the conversation is worth
+[remembering](memory.md), since the summary leaves details out. Tool outputs are capped at 30,000
+characters (head and tail kept) so one noisy command can't flood the window.
 
 ## Memory sizing
 
@@ -78,6 +79,7 @@ the Ollama server you configure, it only contacts the web when the model searche
 | `mcp/` | MCP client: stdio and HTTP transports, OAuth sign-in, server settings, the catalog, `lcode mcp` |
 | `bench.py` | `lcode bench`: the benchmark tasks, their checks and the reports |
 | `vision.py` | Looking at images with a model that can see |
+| `memory.py` | Notes that carry over between sessions, and the end-of-session check |
 | `sandbox.py` | The optional container for shell commands |
 | `checkpoints.py` | Snapshots before the model changes files, for `/undo` and `/rewind` |
 | `catalog.py`, `models.toml` | Model catalog and memory estimates |

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/docs/index.md

@@ -69,6 +69,13 @@ until the task is done, asking before it changes anything.
     Every edit is shown as a diff and every non-read-only command needs your approval, unless you
     choose otherwise. `/undo` takes back a request's file changes.
 
+-   :material-brain:{ .lg .middle } **Remembers what matters**
+
+    ---
+
+    Your corrections, decisions and where things live carry over to the next session as short
+    [notes](memory.md), never whole conversations or secrets.
+
 -   :material-connection:{ .lg .middle } **MCP servers**
 
     ---

lcode_cli-0.7.0/docs/memory.md

@@ -0,0 +1,128 @@
+# Memory
+
+Every session used to start from zero. Whatever you and the model worked out was lost unless
+someone wrote it into `AGENTS.md`: the test command that actually works, "we use pnpm, not npm",
+that the staging database needs the VPN, a correction you had to give twice.
+
+lcode now keeps short **notes** that later sessions load: only key knowledge, not whole
+conversations. A note is one fact, in one line, with optional details.
+
+```text
+❯ /memory
+Memory
+ #  For          Type       Note                                                  Updated
+ 1  every repo   feedback   Prefers short answers without a summary at the end  2026-10-03
+ 2  this repo    project    Run the tests with `uv run pytest -q`; plain pyte…  2026-10-05
+ 3  this repo    reference  Staging logs are in Grafana, dashboard "api-prod"   2026-10-04
+```
+
+## What gets saved
+
+Only what a future session needs and can't find in the code, the git history or `AGENTS.md`. There
+are four kinds:
+
+| Type | For | Example |
+|---|---|---|
+| `feedback` | Your corrections and preferences | "Use pnpm, not npm" |
+| `project` | Decisions, constraints, ongoing work | "The staging database needs the VPN" |
+| `reference` | Where things live outside the repository | "Bugs are tracked in Linear, project API" |
+| `user` | Who you are and how you like to work | "Prefers short answers" |
+
+Never saved: code structure, file paths, what changed in a session (git has that), temporary
+state, and **secrets**. lcode refuses any note that looks like it contains a password, API key,
+token, private key or a URL with a password in it, whoever writes it. Write where the secret lives
+instead ("staging credentials are in 1Password, vault Dev").
+
+## How notes get saved
+
+- **The model** saves a note with its `memory` tool when it learns something worth keeping, for
+  example after you correct it. It can also update a note (same name) or delete one that turned out
+  wrong.
+- **You** save one with `/remember`:
+
+    ```text
+    ❯ /remember the staging database needs the VPN
+    ❯ /remember feedback: don't add docstrings to private functions
+    ❯ /remember -g user: I'm a backend developer; explain frontend code in more detail
+    ```
+
+    `-g` saves it for every repository. Start with `feedback:`, `reference:` or `user:` to set the
+    type (the default is `project`).
+
+- **At the end of a session**, because local models rarely save anything on their own, lcode
+  asks the model one short question: is anything from this session worth remembering? It happens
+  when you quit, on `/clear`, and before the conversation is compacted (the summary leaves details
+  out). The model proposes at most three notes:
+
+    ```text
+    ╭─ Worth remembering? ────────────────────────────────────────────────────────╮
+    │ 1 [feedback] Use pnpm, not npm (this repository)                              │
+    │ 2 [project] Integration tests need `docker compose up db` first (this         │
+    │   repository)                                                                 │
+    ╰───────────────────────────────────────────────────────────────────────────────╯
+      Save them? [y]es / numbers to keep, e.g. 1,3 / [n]o: 1
+    ```
+
+    The question is quick: it reuses the conversation Ollama already has in memory, so the model
+    only writes a few lines. Short sessions (one request and little work) are skipped, and Ctrl+C
+    skips it too.
+
+## Asking first: the `memory` setting
+
+| `memory` | |
+|---|---|
+| `ask` (default) | Every note the model saves, and the end-of-session proposals, need your OK. Answer `a` once to allow the model's notes for the rest of the session. This holds in `yolo` mode too. |
+| `auto` | Notes are saved without asking; lcode prints each one. |
+| `off` | No notes are loaded or saved, and the model has no `memory` tool. |
+
+```bash
+lcode config set memory auto
+```
+
+`lcode --no-memory` turns memory off for one session. `lcode -p` runs never ask the end-of-session
+question.
+
+## Managing notes
+
+| Command | |
+|---|---|
+| `/memory` | List the notes for this repository and for every repository |
+| `/memory show 2` | Show a note with its details (by number or name) |
+| `/memory edit 2` | Open it in your editor (`$VISUAL`, `$EDITOR`, nano or vi) |
+| `/memory delete 2` | Delete it |
+| `/memory path` | Where the notes are stored |
+
+Changes you make with `/memory` apply from the next session. Notes added with `/remember` are
+also mentioned to the model right away.
+
+## How it works
+
+Notes are plain markdown files with a small header, one fact per file:
+
+```markdown
+---
+name: test-command
+type: project
+description: Run the tests with `uv run pytest -q`; plain pytest misses the dev dependencies
+modified: 2026-10-05
+---
+The dev dependencies are in a uv dependency group, which plain pytest doesn't see.
+```
+
+| Folder | Notes |
+|---|---|
+| `~/.local/state/lcode/memory/projects/<repository>/` | For one repository, shared by all its git worktrees and subfolders |
+| `~/.local/state/lcode/memory/user/` | For every repository |
+
+Each folder also has a `MEMORY.md` listing its notes, for reading; lcode regenerates it, so edit
+the notes rather than that file. A folder that isn't in a git repository gets its own notes.
+
+At the start of a session, the model gets a one-line index of the notes (description, name, date)
+in its instructions. The index is capped at about 2,000 tokens, or 5% of a small context window;
+when there are more notes, the newest are shown and the model can list the rest with its `memory`
+tool, which also reads a note's details. The dates let stale facts stand out, and the model is told
+to trust what it finds in the code over an old note, and to fix the note.
+
+Saving under an existing name replaces that note. A new note that says nearly the same as another
+one is not saved twice: the model is told to update the existing note instead, and
+end-of-session proposals that only restate a note are dropped.

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/docs/quickstart.md

@@ -12,12 +12,13 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.6.1 — local coding agent            │
+│ lcode v0.7.0 — local coding agent            │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │
 │ cwd      /home/you/code/my-project           │
 │ mode     ask (Shift+Tab to cycle)            │
+│ memory   ask · no notes yet (/remember)      │
 ╰──────────────────────────────────────────────╯
 ❯
 ```

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/docs/usage.md

@@ -25,6 +25,7 @@ lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases
 | `--no-think` | Turn off the model's reasoning: faster, less accurate |
 | `--no-web` | No web search or page fetching in this session |
 | `--no-mcp` | Don't start [MCP servers](mcp.md) in this session |
+| `--no-memory` | Don't load or save [memory notes](memory.md) in this session |
 | `--sandbox` | Run shell commands in a container that only sees the project ([Sandbox](sandbox.md)) |
 | `--show-thinking` | Print the model's reasoning as it streams |
 | `-V, --version` | Print the version |
@@ -56,6 +57,8 @@ reasoning is on.
 | `/undo` | Undo the file changes of the last request ([details](#undo-and-checkpoints)) |
 | `/rewind [N]` | Go back to before request N: its files, and optionally the conversation |
 | `/checkpoints` | List the requests that changed files, and which files |
+| `/remember [-g] TEXT` | Save a [note](memory.md) for later sessions (`-g`: for every repository) |
+| `/memory [show\|edit\|delete N]` | The [notes](memory.md) lcode remembers |
 | `/sandbox [network on\|off]` | The [sandbox](sandbox.md) for shell commands |
 | `/mcp [tools\|login\|restart NAME]` | [MCP servers](mcp.md), their status and tools |
 | `/compact [focus]` | Summarize the conversation to free context |
@@ -225,6 +228,10 @@ At startup lcode reads `AGENTS.md` (or `LCODE.md`, or `CLAUDE.md`) from the work
 adds it to the model's instructions. Use it for build and test commands, architecture notes and
 conventions. `/init` writes a first version for you.
 
+What doesn't belong in `AGENTS.md` but should carry over, such as your corrections and preferences,
+goes into lcode's [memory](memory.md): short notes the model, you (`/remember`) or a short check at
+the end of a session save, and that every later session in the repository loads.
+
 ## Sessions
 
 Every conversation is saved after each request to `~/.local/state/lcode/sessions/`, so you can

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/mkdocs.yml

@@ -92,6 +92,7 @@ nav:
       - Quickstart: quickstart.md
   - Guide:
       - Using lcode: usage.md
+      - Memory: memory.md
       - Models & context windows: models.md
       - Benchmarking models: bench.md
       - MCP servers: mcp.md

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/pyproject.toml

@@ -69,6 +69,7 @@ ignore = [
 
 [tool.ruff.lint.per-file-ignores]
 "src/lcode/agent.py" = ["E501"] # the prompts are prose; wrapping them would change what the model sees
+"src/lcode/memory.py" = ["E501"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.6.1"
+__version__ = "0.7.0"

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/src/lcode/agent.py

@@ -21,6 +21,7 @@ from rich.panel import Panel
 from rich.text import Text
 
 from lcode import catalog, limits, sessions, vision, web
+from lcode import memory as memory_notes
 from lcode.checkpoints import Checkpoints
 from lcode.config import format_tokens
 from lcode.mcp import McpManager
@@ -29,6 +30,7 @@ from lcode.permissions import Permissions
 from lcode.render import MarkdownStreamer
 from lcode.sandbox import Sandbox, SandboxError, project_root
 from lcode.tools import (
+    MEMORY_SCHEMA,
     SCHEMAS,
     VIEW_IMAGE_SCHEMA,
     WEB_FETCH_SCHEMA,
@@ -74,7 +76,7 @@ SYSTEM_PROMPT = """You are lcode, an autonomous software-engineering agent runni
 
 # Top-level layout of the working directory
 {tree}
-{web}{memory}"""
+{web}{project}{notes}"""
 
 WEB_PROMPT = """
 # Web access
@@ -148,6 +150,7 @@ class Settings:
     sandbox_image: str | None = None
     sandbox_network: bool = False
     vision_model: str = "auto"  # auto, off or an Ollama model that can see images
+    memory: str = "off"  # off, ask or auto: notes that carry over to later sessions (lcode.memory)
 
 
 class Agent:
@@ -170,6 +173,9 @@ class Agent:
         self._vision: str | bool | None = False  # the model that looks at images; False = not decided yet
         self.session_name = ""
         self.session_title = ""
+        self.interactive = True  # False for `lcode -p`: no end-of-session questions
+        self.reflected = 0  # messages before this index were already checked for notes to remember
+        self._memory: memory_notes.Memory | None = None
         self.ctx_used = 0
         self.last_speed = 0.0
         self.usage = {"requests": 0, "prompt_tokens": 0, "prompt_ns": 0, "output_tokens": 0, "output_ns": 0}
@@ -182,11 +188,11 @@ class Agent:
         return dt.datetime.now().strftime("%Y%m%d-%H%M%S-") + uuid.uuid4().hex[:6]
 
     def system_prompt(self) -> str:
-        memory = ""
+        project = ""
         for name in PROJECT_FILES:
             f = self.cwd / name
             if f.is_file():
-                memory = f"\n# Project instructions ({name})\n{truncate(f.read_text(errors='replace'), 20_000)}\n"
+                project = f"\n# Project instructions ({name})\n{truncate(f.read_text(errors='replace'), 20_000)}\n"
                 break
         return SYSTEM_PROMPT.format(
             model=self.settings.model,
@@ -196,10 +202,17 @@ class Agent:
             date=dt.date.today().isoformat(),
             git=git_info(self.cwd),
             tree=tree(self.cwd, depth=1, limit=120),
-            memory=memory,
+            project=project,
+            notes=self.memory().prompt(self.settings.context) if self.settings.memory != "off" else "",
             web=self.web_prompt(),
         )
 
+    def memory(self) -> memory_notes.Memory:
+        """The notes for the current folder's repository, plus the user's own."""
+        if self._memory is None or self._memory.cwd != self.cwd:
+            self._memory = memory_notes.Memory(self.cwd)
+        return self._memory
+
     def search_backend(self) -> str | None:
         if self.settings.web == "off":
             return None
@@ -211,6 +224,8 @@ class Agent:
             schemas += [*([WEB_SEARCH_SCHEMA] if self.search_backend() else []), WEB_FETCH_SCHEMA]
         if self.vision_model():
             schemas.append(VIEW_IMAGE_SCHEMA)
+        if self.settings.memory != "off":
+            schemas.append(MEMORY_SCHEMA)
         if self.mcp:
             schemas += self.mcp.schemas(self.settings.context)
         return schemas
@@ -301,6 +316,7 @@ class Agent:
         self.messages = [{"role": "system", "content": self.system_prompt()}]
         self._mcp_prompt = ""
         self.tools.read_mtimes.clear()
+        self.reflected = len(self.messages)
         self.ctx_used = len(self.messages[0]["content"]) // 3
 
     def session_file(self) -> Path:
@@ -357,6 +373,7 @@ class Agent:
         self.session_name = data.get("name", "")
         self.session_title = data.get("title") or sessions.title_from(self.messages)
         self.tools.read_mtimes.clear()  # files may have changed since; the model must read them again
+        self.reflected = len(self.messages)  # checked for notes to remember when that session ended
         self.ctx_used = sum(len(json.dumps(m)) for m in self.messages) // 3
         return note
 
@@ -513,6 +530,8 @@ class Agent:
             return f"glob({args.get('pattern', '')})"
         if name == "list_dir":
             return f"list_dir({args.get('path', '.')})"
+        if name == "memory":
+            return f"memory({' '.join(str(args.get(k) or '') for k in ('action', 'name')).strip()})"
         if self.mcp and self.mcp.owns(name):
             if name == "mcp_find_tools":
                 return f"mcp_find_tools({args.get('query', '')!r})"
@@ -646,6 +665,8 @@ class Agent:
     def compact(self, focus: str = "") -> None:
         if len(self.messages) <= 2:
             return
+        if self.interactive:
+            memory_notes.reflect(self)  # what the summary leaves out is gone for good
         instructions = (
             "Summarize this conversation so the work can continue in a fresh context. Include: the user's goals "
             "and requests, key facts learned about the codebase (files, functions, paths with line numbers), "
@@ -664,6 +685,7 @@ class Agent:
             {"role": "assistant", "content": "Got it — I have the context from the summary and will continue."},
         ]
         self.ctx_used = sum(len(m["content"]) for m in self.messages) // 3
+        self.reflected = len(self.messages)
         self.console.print(Panel(Markdown(summary), title="Compacted summary", border_style="blue"))
 
     # -- settings changes

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/src/lcode/cli.py

@@ -341,6 +341,13 @@ def cmd_doctor(args) -> None:
         network = "network on" if cfg["sandbox_network"] else "no network"
         line("Sandbox", problem or f"{cfg['sandbox']} · {network}", problem is None)
         ok &= problem is None
+    if cfg["memory"] == "off":
+        line("Memory", "off (lcode config set memory ask)", True)
+    else:
+        from lcode.memory import Memory
+
+        project, user = Memory(Path.cwd()).counts()
+        line("Memory", f"{cfg['memory']} · {project} note(s) for this repository, {user} for every repository", True)
     node = shutil.which("npx")
     line("Node.js", "found" if node else "not found (some MCP servers need npx)", True if node else None)
     sys.exit(0 if ok else 1)
@@ -509,8 +516,10 @@ def cmd_chat(args) -> None:
         sandbox_image=cfg["sandbox_image"],
         sandbox_network=cfg["sandbox_network"],
         vision_model=cfg["vision_model"],
+        memory="off" if args.no_memory else cfg["memory"],
     )
     agent = Agent(ollama, settings, cwd, console=console)
+    agent.interactive = not args.prompt
     if agent.sandbox:
         # Never run commands unsandboxed when the user asked for a sandbox: stop here instead.
         from lcode.sandbox import SandboxError
@@ -557,6 +566,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--no-think", action="store_true", help="disable model reasoning (faster, less accurate)")
     parser.add_argument("--no-web", action="store_true", help="don't let the model search or fetch web pages")
     parser.add_argument("--no-mcp", action="store_true", help="don't start MCP servers in this session")
+    parser.add_argument("--no-memory", action="store_true", help="don't load or save memory notes in this session")
     parser.add_argument("--sandbox", action="store_true", help="run shell commands in a container (Docker or Podman)")
     parser.add_argument("--show-thinking", action="store_true", help="print the model's reasoning as it streams")
     parser.add_argument("-V", "--version", action="version", version=f"lcode {__version__}")

{lcode_cli-0.6.1 → lcode_cli-0.7.0}/src/lcode/config.py

@@ -26,6 +26,7 @@ WEB_MODES = ("on", "ask", "off")
 SEARCH_BACKENDS = ("auto", "ollama", "brave", "tavily", "searxng")
 MCP_TOOL_MODES = ("auto", "direct", "search")
 SANDBOX_ENGINES = ("off", "docker", "podman")
+MEMORY_MODES = ("off", "ask", "auto")
 
 # key -> (default, type, help)
 SETTINGS: dict[str, tuple[object, type, str]] = {
@@ -45,6 +46,7 @@ SETTINGS: dict[str, tuple[object, type, str]] = {
     "sandbox_network": (False, bool, "let commands in the sandbox use the network"),
     "vision_model": ("auto", str, "model that looks at images: auto | off | an Ollama model with vision"),
     "mcp_tools": ("auto", str, "how MCP tools reach the model: auto | direct | search (on demand, saves context)"),
+    "memory": ("ask", str, "notes that carry over to later sessions: off | ask (confirm each) | auto"),
 }
 ENV_OVERRIDES = {
     "LCODE_MODEL": "model",
@@ -54,6 +56,7 @@ ENV_OVERRIDES = {
     "OLLAMA_HOST": "ollama_host",
     "LCODE_WEB": "web",
     "LCODE_SANDBOX": "sandbox",
+    "LCODE_MEMORY": "memory",
 }
 
 
@@ -110,6 +113,11 @@ def coerce(key: str, value: object) -> object:
         if value not in SANDBOX_ENGINES:
             raise ConfigError(f"sandbox must be one of {', '.join(SANDBOX_ENGINES)}")
         return value
+    if key == "memory":
+        value = {"on": "ask", "true": "ask", "false": "off", "no": "off"}.get(str(value).lower(), str(value).lower())
+        if value not in MEMORY_MODES:
+            raise ConfigError(f"memory must be one of {', '.join(MEMORY_MODES)}")
+        return value
     if key == "mcp_tools" and value not in MCP_TOOL_MODES:
         raise ConfigError(f"mcp_tools must be one of {', '.join(MCP_TOOL_MODES)}")
     if key == "search_backend" and value not in SEARCH_BACKENDS: