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

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

@@ -6,6 +6,45 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.9.0] - 2026-10-05
+
+### Added
+
+- Plan mode: a `plan` permission mode (Shift+Tab from `ask`, `/mode plan`, `lcode --plan`, or
+  `/plan <request>`) in which the model can read, search, run read-only commands, use the web and
+  read-only subagents, but can't change anything. It presents a plan with the new `present_plan`
+  tool, and you approve it (in `ask` or `auto-edit` mode), edit it, save it to `.lcode/plans/`, or
+  send it back with feedback. An approved plan fills the todo list and is kept through compaction;
+  `/plan` shows it. See [Plan mode](https://nasser1941.github.io/lcode/usage/#plan-mode).
+
+### Fixed
+
+- `lcode mcp add` shows the default value in its questions again, such as `AWS region
+  [us-east-1]`; the terminal formatting swallowed it.
+- The end-of-session "Worth remembering?" list shows each note's type (`[feedback]`, `[project]`, …),
+  which the same problem hid.
+
+## [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
@@ -225,7 +264,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.7.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.9.0...HEAD
+[0.9.0]: https://github.com/nasser1941/lcode/compare/v0.8.0...v0.9.0
+[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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.7.0
+Version: 0.9.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/
@@ -80,8 +80,13 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   your approval. `auto-edit` and `yolo` modes when you want speed.
 - **Sandbox (optional).** `lcode --sandbox` runs the model's shell commands in a container (Docker or
   Podman) that only sees your project, without network access unless you allow it.
+- **Plan mode.** `/plan <request>` or Shift+Tab: the model explores read-only and presents a plan;
+  you approve, edit or send it back before anything changes.
 - **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.
@@ -192,8 +197,7 @@ 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)
+- [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))

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

@@ -46,8 +46,13 @@ through [Ollama](https://ollama.com), and when it needs current information it c
   your approval. `auto-edit` and `yolo` modes when you want speed.
 - **Sandbox (optional).** `lcode --sandbox` runs the model's shell commands in a container (Docker or
   Podman) that only sees your project, without network access unless you allow it.
+- **Plan mode.** `/plan <request>` or Shift+Tab: the model explores read-only and presents a plan;
+  you approve, edit or send it back before anything changes.
 - **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.
@@ -158,8 +163,7 @@ 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)
+- [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))

lcode_cli-0.9.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.7.0 → lcode_cli-0.9.0}/docs/configuration.md

@@ -20,7 +20,7 @@ lcode config path                      # print the file location
 | `num_batch` | 512 | Prompt batch size. Larger reads prompts faster but needs more GPU memory |
 | `keep_alive` | `30m` | How long Ollama keeps the model in memory after the last request |
 | `ollama_host` | `http://localhost:11434` | Ollama server URL |
-| `permission_mode` | `ask` | `ask`, `auto-edit` or `yolo` |
+| `permission_mode` | `ask` | `ask`, `plan`, `auto-edit` or `yolo` |
 | `think` | `true` | Let the model reason before answering |
 | `web` | `on` | Web search and page fetching: `on`, `ask` (before each search/website) or `off` |
 | `search_backend` | `auto` | `auto`, `ollama`, `brave`, `tavily` or `searxng`; `auto` uses the first one configured |
@@ -31,6 +31,8 @@ lcode config path                      # print the file location
 | `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:
@@ -72,6 +74,7 @@ Environment variables override the file, which is useful for one-off runs and CI
 | `~/.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.7.0 → lcode_cli-0.9.0}/docs/how-it-works.md

@@ -29,6 +29,15 @@ 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.
@@ -79,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 |
+| `planning.py` | Plan mode: what it allows, presenting a plan and approving it |
 | `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` |

{lcode_cli-0.7.0 → lcode_cli-0.9.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-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**
 
     ---

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

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

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

@@ -20,6 +20,7 @@ lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases
 | `-r, --repo DIR` | Work in another directory |
 | `-c, --continue` | Continue the most recently used session in this directory |
 | `--resume [SESSION]` | Resume a saved session: pick from a list, or give its number, name or id |
+| `--plan` | Start in [plan mode](#plan-mode): agree on a plan before anything changes |
 | `--auto-edit` | Apply file edits without asking (commands still ask) |
 | `--yolo` | Never ask for permission |
 | `--no-think` | Turn off the model's reasoning: faster, less accurate |
@@ -38,9 +39,10 @@ lcode mcp [catalog|add|list] # connect MCP servers: Jira, GitHub, AWS, databases
 | ++esc++ ++enter++ or a trailing `\` | New line |
 | ++ctrl+c++ | Interrupt the model or a running command |
 | ++ctrl+d++ | Quit |
-| ++shift+tab++ | Cycle permission mode: ask → auto-edit → yolo |
+| ++shift+tab++ | Cycle permission mode: ask → plan → 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.
@@ -57,16 +59,18 @@ 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 |
+| `/plan [request]` | Work out a [plan](#plan-mode) before changing anything, or show the approved plan |
 | `/compact [focus]` | Summarize the conversation to free context |
 | `/context [size]` | Show how full the context window is and change its size: pick from a list with memory estimates, or give a size like `/context 128k` (`/ctx` is a shortcut) |
 | `/model [name]`, `/models` | Switch model, list models |
 | `/think [on\|off]` | Toggle reasoning |
 | `/verbose` | Toggle showing the reasoning text |
-| `/mode [ask\|auto-edit\|yolo]` | Set the permission mode |
+| `/mode [ask\|plan\|auto-edit\|yolo]` | Set the permission mode |
 | `/cd DIR` | Change the working directory |
 | `/todos` | Show the model's task list |
 | `/exit` | Quit |
@@ -85,6 +89,10 @@ 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 |
+| `present_plan` | In [plan mode](#plan-mode): show the plan and ask for approval |
 
 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.
@@ -122,12 +130,16 @@ image support off with `lcode config set vision_model off`.
 | Mode | File edits | Shell commands |
 |---|---|---|
 | `ask` (default) | ask | ask, except read-only commands |
+| `plan` | refused | only read-only commands ([Plan mode](#plan-mode)) |
 | `auto-edit` | automatic | ask, except read-only commands |
 | `yolo` | automatic | automatic |
 
+++shift+tab++ cycles through them in this order, `/mode` sets one, and `--plan`, `--auto-edit` and
+`--yolo` start in one.
+
 Read-only commands run without asking: `ls`, `cat`, `head`, `tail`, `grep`, `rg`, `find`, `tree`,
 `wc`, `diff`, `git status/log/diff/show/branch/blame` and similar, as long as they don't redirect
-output, chain commands or run subshells.
+output, chain commands or run subshells. A `cd <folder> &&` in front is fine.
 
 When asked, answer ++y++ (once), ++a++ (always, for this command or for all edits, until you quit)
 or ++n++. Text after ++n++ goes to the model as instructions: `n run the tests with -x first`.
@@ -141,6 +153,42 @@ or ++n++. Text after ++n++ goes to the model as instructions: `n run the tests w
 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.
 
+## Plan mode
+
+Local models are slower than cloud models and make more mistakes, so on a bigger change it pays to
+agree on the approach before the model starts editing. In **plan mode** the model can read, search,
+run read-only commands, use the web and [explore and plan subagents](agents.md), but it can't
+change anything. It ends by presenting a plan: numbered steps, the files it will change, the risks
+and how it will verify the work.
+
+```text
+❯ /plan add retries to the webhook handlers
+  …
+╭─ Plan: Retries for webhook handlers ───────────────────────────────────────────╮
+│ 1. Wrap the HTTP call in payments/webhooks.py:88 in a retry loop (3 tries, …)  │
+│ 2. Add tests for a timeout and a 500 in tests/test_webhooks.py                 │
+│ Risks: duplicate deliveries if the endpoint isn't idempotent …                 │
+│ Verify: pytest tests/test_webhooks.py                                          │
+╰────────────────────────────────────────────────────────────────────────────────╯
+  [y] run it, asking before changes · [a] run it, edits without asking (auto-edit)
+  [e] edit the plan · [s] save it to .lcode/plans/ · [n] keep planning (+ what to change)
+  >
+```
+
+| Answer | |
+|---|---|
+| ++y++ or ++enter++ | Approve: lcode switches to `ask` mode and the model starts on the plan right away |
+| ++a++ | Approve and switch to `auto-edit`, so file edits don't ask |
+| ++e++ | Edit the plan in your editor first; the model follows your version |
+| ++s++ | Save it as `.lcode/plans/<title>.md`, for example to share it or commit it |
+| ++n++ + text | Send it back: `n keep the old API working` |
+
+After approval, the todo list is filled from the plan's numbered steps, and the plan is kept word
+for word when the conversation is compacted. `/plan` shows the approved plan.
+
+Start planning with `/plan <request>` (switches to plan mode and sends the request), with
+++shift+tab++ (one step from `ask`), or with `lcode --plan`.
+
 ## Undo and checkpoints
 
 Before the model first changes anything in a request (an edit, a new file, or a shell command that

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

@@ -93,6 +93,7 @@ nav:
   - 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.7.0 → lcode_cli-0.9.0}/pyproject.toml

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

{lcode_cli-0.7.0 → lcode_cli-0.9.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.7.0"
+__version__ = "0.9.0"