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

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

@@ -6,6 +6,41 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-10-05
+
+### Added
+
+- Subagents: the model can hand a task to a subagent with its own fresh context through the new
+  `agent` tool, and only the subagent's report comes back, so exploring a large codebase or reading
+  long output doesn't fill the main context. Built-in types: `explore` and `plan` (read-only) and
+  `worker` (all tools). Custom agents are markdown files in `.lcode/agents/` or
+  `~/.config/lcode/agents/`; `@name` asks for one. Subagents use the session's model and context
+  window (no reload), permissions (prompts are labelled with the agent), sandbox and checkpoints
+  (`/undo` covers their changes). With `max_parallel_agents` above 1 and Ollama's
+  `OLLAMA_NUM_PARALLEL`, several run at the same time; workers that do get their own git worktree
+  and their changes come back as a diff to approve. `/agents` shows the types and what each
+  subagent did; `lcode doctor` estimates how many could run at once. See
+  [Subagents](https://nasser1941.github.io/lcode/agents/).
+
+### Changed
+
+- A shell command that starts with `cd <folder> &&` counts as read-only when the rest of it does,
+  so `cd src && grep -n foo *.py` runs without asking. A `cd` with `$(…)` or backticks still asks.
+
+## [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 +246,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.6.1...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/nasser1941/lcode/compare/v0.7.0...v0.8.0
+[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.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.6.1
+Version: 0.8.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,12 @@ 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.
+- **Subagents.** The model hands broad searches, planning and self-contained changes to subagents
+  with their own fresh context, so the main conversation keeps only their reports. Define your own
+  agent types in `.lcode/agents/`.
+- **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 +195,9 @@ 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:
 
+- [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.8.0}/README.md

@@ -48,6 +48,12 @@ 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.
+- **Subagents.** The model hands broad searches, planning and self-contained changes to subagents
+  with their own fresh context, so the main conversation keeps only their reports. Define your own
+  agent types in `.lcode/agents/`.
+- **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 +161,9 @@ 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:
 
+- [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.8.0/docs/agents.md

@@ -0,0 +1,145 @@
+# Subagents
+
+A single conversation used to do everything. Exploring a large codebase, reading logs or comparing
+approaches fills the context window with material that's only needed for a moment, and that hurts
+most at 32K to 128K.
+
+Now the model can hand a task to a **subagent**: a fresh agent with its own empty context that
+works on the task alone and returns only its report. The main conversation keeps the answer, not
+the 40 files the subagent read to find it.
+
+```text
+❯ how do the payment webhooks get verified, and where would I add retries?
+  ✓ ↳ explore: find webhook verification · 9 tools · 41s
+  ✓ ↳ plan: retries for webhook handlers · 6 tools · 38s
+Webhooks are verified in `payments/webhooks.py:88` …
+```
+
+## Agent types
+
+| Type | Does | Tools |
+|---|---|---|
+| `explore` | Finds code and answers questions about the codebase | Read-only: reading and searching files, read-only shell commands, the web |
+| `plan` | Works out a step-by-step plan for a change, without making it | Read-only, like explore |
+| `worker` | Makes a self-contained change and verifies it | All of lcode's tools |
+
+The model picks the type and writes the task. A subagent can't see the conversation, so the model
+is told to describe the task completely. Subagents can't start subagents of their own, and they
+don't save [memory](memory.md) notes; they do see the notes and `AGENTS.md`.
+
+To ask for a specific agent yourself, mention it: `@plan add a dark mode toggle` (or
+`@agent-plan …`).
+
+## What you see
+
+Each subagent gets one progress line with its current action, its tool count and its time. When it
+finishes, the line stays as a summary. `/agents` lists the agent types and the subagents of this
+session; `/agents 2` shows what the second one did, call by call.
+
+Ctrl+C stops the subagents and the request.
+
+## Safety
+
+Subagents work under the session's rules:
+
+- **Permissions.** They use the session's permission mode. Every prompt names the agent
+  (`worker agent › Run command`) and is asked in the main terminal, one at a time, even when
+  several agents run at once.
+- **Read-only agents** (`explore`, `plan`) can't edit files, and lcode refuses any shell command that
+  isn't on the read-only list.
+- **Undo.** A worker's changes are part of your request's checkpoint, so `/undo` takes them back.
+- **Sandbox.** With the [sandbox](sandbox.md) on, their commands run in it too.
+
+## Several at once
+
+When the model calls several agents in one response, lcode can run them at the same time. Whether
+that helps depends on Ollama:
+
+- By default **Ollama runs one request at a time**. Two agents would take turns, and each turn would
+  push the other's conversation out of Ollama's prompt cache, which makes both slower. So lcode
+  runs subagents one after another by default (`max_parallel_agents = 1`).
+- Ollama runs several requests at once when its server is started with `OLLAMA_NUM_PARALLEL`. Each
+  parallel request gets **its own context cache**, so memory use grows with every slot.
+
+To run two at once:
+
+```bash
+OLLAMA_NUM_PARALLEL=2 ollama serve
+lcode config set max_parallel_agents 2
+```
+
+`lcode doctor` estimates how many fit with your model and context window:
+
+```text
+✓ Agents     subagents one at a time
+!            2 could run at once here (2 × 256K context fits): set OLLAMA_NUM_PARALLEL=2 on the
+             Ollama server and max_parallel_agents 2
+```
+
+### On a 12 GB GPU
+
+Subagents use **the session's model and context window**. A different window, or a different
+model, would make Ollama reload the model, and on one GPU that costs more than the subagent saves.
+Some guidance:
+
+- With one slot (the default), a subagent's requests push the main conversation out of Ollama's
+  cache, so the main model reads its whole context again afterwards. qwen3.6-35b reads about 850
+  tokens a second on a 12 GB laptop GPU: ~35 s for a 30K-token conversation. Delegating pays off when the subagent
+  would otherwise add much more than that to the main context.
+- Two slots keep the main conversation cached while a subagent works. qwen3.6-35b's context cache
+  is small, so two slots of 128K fit in 12 GB of VRAM plus system RAM, but the extra cache sits in
+  system RAM and slows the model down.
+- Smaller context windows leave room for more slots: `/context 64k` with
+  `OLLAMA_NUM_PARALLEL=3`.
+
+## Workers that run together
+
+A worker edits your working tree directly. When **two or more workers** (or other agents that can
+change files) run at the same time, each gets its own **git worktree** instead, created from your
+working tree as it is now, uncommitted and untracked files included. When a worker finishes,
+lcode shows its changes as a diff and asks before applying them to your working tree. The diff is
+applied automatically in `auto-edit` and `yolo` mode. If the diff doesn't apply cleanly, lcode
+saves it as a patch file and tells the model where.
+
+Worktrees live in `.git/lcode-worktrees/` and are removed when the worker is done. Outside a git
+repository, or before the first commit, workers run one after another in the working tree.
+
+## Custom agents
+
+Define your own agent types as markdown files: the frontmatter describes the agent, and the body is
+its instructions.
+
+```markdown
+---
+description: reviews a change for bugs and missing tests (read-only)
+tools: read-only
+max_steps: 30
+---
+Review the change described in the task. Read the changed code and its callers.
+Report bugs first, with `path:line`, then missing tests, then style. Don't fix anything.
+```
+
+| Key | Meaning |
+|---|---|
+| `description` | What it does; the main model reads this to decide when to use it (required) |
+| `tools` | `all` (default), `read-only`, or a list such as `read_file, grep, bash` |
+| `read_only` | `true` to allow only read-only shell commands (set by `tools: read-only`) |
+| `max_steps` | Tool-calling steps before it must report (default 60, at most 200) |
+| `model` | Another Ollama model for this agent. Only worth it if both fit in memory at once |
+| `isolation` | `auto` (default: a worktree only when running with other editing agents), `worktree` (always) or `none` |
+
+| Folder | Agents |
+|---|---|
+| `.lcode/agents/<name>.md` in the repository | For this repository; commit them to share them |
+| `~/.config/lcode/agents/<name>.md` | For every repository |
+
+The file name is the agent's name. A repository's agent overrides one of yours with the same name,
+and both override the built-in types. `/agents` and `lcode doctor` point out files that couldn't be
+read.
+
+## Settings
+
+| Setting | Default | |
+|---|---|---|
+| `subagents` | `true` | Let the model use the `agent` tool |
+| `max_parallel_agents` | `1` | How many subagents run at the same time (see [Several at once](#several-at-once)) |

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

@@ -30,6 +30,9 @@ 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` |
+| `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)) |
 | `checkpoints` | `true` | Save a checkpoint before the model changes files, so [`/undo`](usage.md#undo-and-checkpoints) can restore them |
 
 Example file:
@@ -55,6 +58,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 +73,8 @@ 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 |
+| `~/.config/lcode/agents/` | Your [custom agents](agents.md#custom-agents) (a repository's go in `.lcode/agents/`) |
 | `~/.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.8.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
@@ -29,13 +29,23 @@ 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).
 
+## Subagents
+
+The `agent` tool starts a [subagent](agents.md): another agent loop with its own conversation, the
+same model and context window (so Ollama doesn't reload anything), the session's permissions,
+sandbox and checkpoints, and a filtered set of tools. Only its final report goes back into the main
+conversation. Several subagents run in threads when `max_parallel_agents` allows; their permission
+prompts are queued and asked in the main thread. Workers that edit files at the same time each work
+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. 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 +88,8 @@ 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 |
+| `subagents.py` | Subagents: agent types, running them (also in parallel), worktrees for workers |
+| `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.8.0}/docs/index.md

@@ -69,6 +69,20 @@ 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-account-multiple-outline:{ .lg .middle } **Subagents**
+
+    ---
+
+    Broad searches, planning and self-contained changes go to [subagents](agents.md) with their own
+    context, so the main conversation stays small.
+
+-   :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.8.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.8.0}/docs/quickstart.md

@@ -12,12 +12,13 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.6.1 — local coding agent            │
+│ lcode v0.8.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.8.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 |
@@ -40,6 +41,7 @@ lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases
 | ++shift+tab++ | Cycle permission mode: ask → auto-edit → yolo |
 | ++tab++ | Complete slash commands and `@` paths |
 | `@path` | Attach a file (or a directory listing) to your message |
+| `@name` | Ask for a [subagent](agents.md) of that type, e.g. `@plan` |
 
 The status bar shows the model, how full the context window is, the permission mode and whether
 reasoning is on.
@@ -56,6 +58,9 @@ 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 |
+| `/agents [N]` | [Subagent](agents.md) types, and what this session's subagents did |
+| `/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 |
@@ -82,6 +87,9 @@ reasoning is on.
 | `todo_write` | Keep a visible task list for multi-step work |
 | `web_search` | Search the web for current information (needs a [search provider](#web-search)) |
 | `web_fetch` | Read a web page or text file by URL as clean text |
+| `view_image` | Look at an image: a model that can see describes it ([Images](#images)) |
+| `agent` | Hand a task to a [subagent](agents.md) with its own context; only its report comes back |
+| `memory` | Save, update or delete [notes](memory.md) that later sessions load |
 
 lcode refuses to edit a file the model hasn't read in the session, or one that changed on disk since
 it was read, so the model always edits the current version.
@@ -225,6 +233,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.8.0}/mkdocs.yml

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

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

@@ -69,6 +69,8 @@ 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"]
+"src/lcode/subagents.py" = ["E501"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{lcode_cli-0.6.1 → lcode_cli-0.8.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.8.0"