deel-local-cli 1.1.1 → 1.4.0

package/README.en.md

@@ -53,16 +53,22 @@ Zero dependencies · Node 20+ · Exactly one place your source can go
 - [Simple vs developer](#simple-vs-developer)
 - [Tools](#tools)
 - [Korean text and Excel](#korean-text-and-excel)
+- [Serving what you built](#serving-what-you-built)
 - [Skills and plugins](#skills-and-plugins)
 - [Reasoning effort](#reasoning-effort)
 - [Auto-compaction](#auto-compaction)
 - [Resuming a conversation](#resuming-a-conversation)
 - [Attaching tools from outside (MCP)](#attaching-tools-from-outside-mcp)
+- [Inside your editor (ACP)](#inside-your-editor-acp)
+- [Keeping secrets out of the conversation](#keeping-secrets-out-of-the-conversation)
 - [Safety](#safety)
 - [Corporate review package](#corporate-review-package)
 - [Configuration](#configuration)
 - [Troubleshooting](#troubleshooting)
 - [Development](#development)
+- [Release notes](#release-notes)
+
+Each section is open at the summary. Click **▸ More** to unfold the detail behind it.
 
 ---
 
@@ -93,6 +99,29 @@ deel audit                             # full review sheet
 
 ## Quick start
 
+### The screen speaks English too
+
+deel is written in Korean — the code, the function names, the comments. That part stays.
+What you see on screen does not have to.
+
+```bash
+DEEL_LANG=en deel        # this run only
+/lang en                 # and remember it
+/lang                    # how much is translated so far
+```
+
+Untranslated lines come through in Korean rather than as blanks, and `/lang` tells you exactly
+how many are left.
+
+What the model reads follows the same switch. Set it to English and the rules, the mode
+instructions, and the tool descriptions all go out in English — so the model answers you in
+English instead of Korean. That side is cheaper, too: the part of the window that ships on every
+single request drops from about 4,900 tokens to about 3,450 — on a 32k model, from 15% of the
+window to 10.5%.
+
+Tool names and argument names stay Korean (`목적`, `할일`, `번호`). Those are identifiers, not
+prose — rename them and the tool stops being called at all.
+
 ### Install
 
 ```bash
@@ -203,6 +232,9 @@ $ deel scan
 
 Switch with `/model` mid-conversation — **the conversation carries over.**
 
+<details>
+<summary><b>More</b> — It adapts to whatever model is attached · Small windows get a smaller fixed share · On startup it reads what kind of project this folder is</summary>
+
 ### It adapts to whatever model is attached
 
 If you move between models, any number tuned for one of them is wrong for all the others.
@@ -333,6 +365,8 @@ can be recovered with one `Glob`; "tests run with `npm test`" requires opening
 
 7ms on a folder with 600 files (`test/project.test.js`).
 
+</details>
+
 ---
 
 ## Slash commands
@@ -342,13 +376,22 @@ Names follow Claude Code / Codex conventions.
 | Command | What it does |
 |---|---|
 | `/help` | Command list |
+| `/lang [ko\|en]` | Screen language. Falls back to Korean for anything not translated yet |
+| `/bell [on\|off]` | Ring and set the window title when a turn ends, or when deel needs an answer |
+| `/consult <profile> <question>` | Ask a second model one question. Your current model stays put |
+| `/lsp [on\|off]` | Language servers — what is installed, and whether `Def`/`Refs` are available. `off` turns post-edit diagnostics off only |
 | `/context` | What is consuming the context window |
 | `/ctx [auto\|number]` | Context **length** — re-read it off the model, or set it yourself |
 | `/grade [small\|medium\|large\|auto]` | Model **grade** — how much it does on its own. A different axis from `/ctx` |
 | `/out [number\|auto]` | Cap on a **single reply** — raise it when large files get cut |
 | `/compact` | Summarise and fold older turns |
 | `/clear` | Clear the conversation (keeps link and rules) |
+| `/thread [new\|fork\|close\|n]` | Conversation threads — side work in its own context. Link and undo stay shared |
+| `/learned [clear]` | What deel has picked up on its own — commands that work here, this model's habits |
+| `/pin <text>` | Pin a line — folding and compaction **cannot reach it** |
+| `/evidence [file]` | Evidence — what changed, and what proves it. **What is unproven is listed too** |
 | `/model` | Switch connection / model |
+| `/model 카드` | Model card — what this model has actually done here, and what deel changed because of it |
 | `/think <level>` | Reasoning level (`off·low·medium·high·max`) |
 | `/think 배분 <profile>` | Per-stage profile (`even·save·deep`) |
 | `/think 자세히` | Stage table — which stage runs at which level and cap |
@@ -359,6 +402,7 @@ Names follow Claude Code / Codex conventions.
 | `/level [level]` | How much to show (`쉬움` simple · `개발자` developer) |
 | `/undo [turns]` | Revert file changes |
 | `/diff [file]` | Files changed this session, and the changed lines |
+| `/preview [folder\|file\|off]` | Serve what you built, right here — a browser opens with it |
 | `/tools` | Available tools |
 | `/skills [query\|all\|off]` | Browse, search, load skills |
 | `/plugin [install\|remove\|pack]` | Manage plugins |
@@ -390,6 +434,9 @@ the conversation.
 
 Korean IME composition, paste, `Ctrl+A/E` and backspace all keep working.
 
+<details>
+<summary><b>More</b> — Attaching a file with @ · Interrupting</summary>
+
 ### Attaching a file with `@`
 
 Write `@` followed by a path and that file is sent along with your message.
@@ -448,6 +495,8 @@ session. Tools already running finish; **tools not yet started never run.**
 
 Pressing Ctrl+C again on an empty line quits.
 
+</details>
+
 ---
 
 ## Work modes
@@ -476,6 +525,9 @@ Don't confuse this with `/mode`. They are separate axes:
 If you have explicitly set `/think` or `/mode`, your choice wins. A work mode never
 overrides something a person chose.
 
+<details>
+<summary><b>More</b> — Switching by itself (Auto mode)</summary>
+
 ### Switching by itself (Auto mode)
 
 You start in **Auto**. Nothing has been decided about what kind of work is coming.
@@ -518,6 +570,8 @@ A `~` in the status line means it switched by itself; no `~` means you chose it.
 
 Choosing a mode yourself **pins** it. `/auto` (or `/work auto`) hands the wheel back.
 
+</details>
+
 ---
 
 ## Simple vs developer
@@ -539,6 +593,9 @@ Two things matter here:
 - **Beginners do not get fewer safeguards.** Undo, workspace scope and dangerous-command
   blocking are identical. A beginner needs the undo more, not less.
 
+<details>
+<summary><b>More</b> — The input box · You don't have to type the whole command · The box stays while it works · The picture on the left moves too and 1 more</summary>
+
 ### The input box
 
 Launched in a terminal, **the conversation scrolls normally and an input box is pinned at
@@ -652,21 +709,46 @@ more than a blank screen. One turn reads like this:
 (turning it over)       (looking at files)     (writing code)    (writing the answer)
 ```
 
-| Activity | Phrases |
-|---|---|
-| Thinking | 머리 굴리는 중 · 어떻게 할지 궁리하는 중 · 수 읽는 중 · 따져 보는 중 |
-| `Read` `Grep` `Glob` | 파일 들여다보는 중 · 코드 훑는 중 · 어디 있나 뒤지는 중 · 단서 찾는 중 |
-| `Write` `Edit` `Append` | 코드 짜는 중 · 고쳐 넣는 중 · 손보는 중 · 한 줄씩 옮기는 중 |
-| `Bash` | 명령 돌리는 중 · 터미널 두드리는 중 · 결과 기다리는 중 |
-| `WebFetch` | 문서 찾아보는 중 · 읽어 오는 중 |
-| Answering | 답 쓰는 중 · 정리해서 말하는 중 |
-| **Past 45 seconds** | 아직 하는 중 · 조금만 더 · 생각보다 오래 걸리는 중 |
+The phrases are Korean, because the interface is. Here is what each set means:
+
+| Activity | On screen | Roughly |
+|---|---|---|
+| Thinking | 머리 굴리는 중 · 어떻게 할지 궁리하는 중 · 수 읽는 중 · 따져 보는 중 | turning it over · working out how · reading ahead · weighing it up |
+| `Read` `Grep` `Glob` | 파일 들여다보는 중 · 코드 훑는 중 · 어디 있나 뒤지는 중 · 단서 찾는 중 | looking at files · skimming code · hunting for where it is · looking for a clue |
+| `Write` `Edit` `Append` | 코드 짜는 중 · 고쳐 넣는 중 · 손보는 중 · 한 줄씩 옮기는 중 | writing code · patching it in · touching it up · moving it a line at a time |
+| `Bash` | 명령 돌리는 중 · 터미널 두드리는 중 · 결과 기다리는 중 | running a command · at the terminal · waiting on output |
+| `WebFetch` | 문서 찾아보는 중 · 읽어 오는 중 | looking up docs · fetching |
+| Answering | 답 쓰는 중 · 정리해서 말하는 중 | writing the answer · putting it together |
+| **Past 45 seconds** | 아직 하는 중 · 조금만 더 · 생각보다 오래 걸리는 중 | still going · nearly there · taking longer than expected |
 
 Within a category the phrase advances every 4 seconds — text frozen for 30 seconds reads as
 hung too. On the right: **elapsed time**, and while the model is reasoning, **how many
 characters of thinking have arrived**. One number that genuinely increases is what turns
 "still alive" from a claim into a fact.
 
+### The picture on the left moves too
+
+What spins next to the phrase is not a spinner — it is **a small drawing of the work being
+done right now**.
+
+| Doing | One cycle | The picture |
+|---|---|---|
+| Thinking | `⠀⠶⠀` `⠰⣿⠆` `⢾⣿⡷` `⠰⣿⠆` | swells and shrinks |
+| Reading | `⠉⠉⠉` `⠒⠒⠒` `⠤⠤⠤` `⣀⣀⣀` | a scanning line travels down |
+| Writing | `⡼⠭⠧` `⠼⡯⠧` `⠼⠿⡧` `⠼⡭⠧` | **a laptop typing** |
+| Commands | `⠉⠀⠀` `⠉⠈⠀` `⠛⠊⠀` `⠿⠮⠄` | output piles up a line at a time |
+| Answering | `⠉⠀⠀` `⠛⠉⠀` `⠿⠛⠉` `⣿⠿⠛` | text fills up |
+| Web | `⣀⣀⣀` `⣤⣀⣀` `⣶⣤⣀` `⣿⣶⣤` | signal bars grow |
+| Compacting | `⣿⣿⣿` `⣶⣶⣶` `⣤⣤⣤` `⣀⣀⣀` | pressed down into one line |
+| Past 45 seconds | `⠶⠀⠀` `⠰⠆⠀` `⠀⠶⠀` `⠀⠰⠆` | back and forth — "waiting" |
+
+Braille only. One braille cell is **2 wide by 4 dots tall**, so three cells make a 6×4 grid
+that is exactly three columns in any terminal. Emoji and `●` `▪` include glyphs that East
+Asian locales measure as two columns, which knocks the border out of line every 90ms.
+
+If the drawing does not render, or you use a screen reader, `DEEL_NO_MOTION=1` turns it off
+and you get the old single-cell spinner.
+
 ### What gets asked, and what just happens
 
 Whether your files change **with or without being asked** is the one thing that has to be
@@ -706,6 +788,8 @@ press only makes it ask more; it never drops you into "changes files unasked" in
 > approval indicator off the line entirely. Now **the model name shortens first** — you
 > already know what you are running; whether your files change unasked is what you need now.
 
+</details>
+
 ---
 
 ## Tools
@@ -730,12 +814,17 @@ Names and arguments match Claude Code, so skills written for that convention wor
 | `Verify` | Check that what was built **actually works** |
 | `Task` | Run one chunk of a big job in a **separate context** |
 | `Jobs` | Inspect, read and stop **background commands** — the other half of `Bash`'s `background` |
+| `Def` | **Where a name is defined** — only shown when a language server is installed |
+| `Refs` | **Every place a name is used** — only shown when a language server is installed |
 
 Seven tools here are not in Claude Code — `Append`, `Recall`, `Remember`, `Outline`,
 `Verify`, `Task`, `Jobs`. Each tool costs 150-400 tokens of schema on **every request**,
 so a test stops you every time the list grows (`test/loop.test.js`). The last four earned
 their cost; here is why.
 
+<details>
+<summary><b>More</b> — Outline · Verify · Task · Def · Refs · Commands that never finish and 9 more</summary>
+
 ### Seeing a project's shape cheaply — `Outline`
 
 There used to be only two ways to understand someone else's code. `Glob` gives you paths;
@@ -1126,10 +1215,125 @@ last edit did. That original state comes from the earliest undo snapshot.
 `/diff` is **in the simple level's command list.** As long as `auto` edits without asking,
 a beginner needs a way to see what changed more than anyone.
 
+### With a language server, it sees meaning — `Def` and `Refs`
+
+`Grep` finds **text**; a language server knows **meaning**. Grep for `run` and you get the
+`run` in a comment, the `run` in a third-party library, the `run` inside a string. Which of
+those actually call that function is something a person has to open one by one. The model
+cannot afford that, so it edits based on the first few hits, and **the ones it missed only
+surface once you run the thing.**
+
+```
+⏺ Refs(add_up)
+  add_up — used in 3 places · 2 files
+
+  src/use.py (2)
+    4: return add_up(1, 2)
+    9: return add_up(x, x)
+  src/other.py (1)
+    2: value = add_up(9, 9)
+```
+
+`Grep` stays. When you rename something outright you actually need it — a language server
+does not look at comments, config or docs. These two **add to** what was here; they do not
+replace it.
+
+They take a **name**, not a position. LSP asks "this file, this line, this column", but the
+model does not know the column. Finding out means reading the file first, and that throws
+away the whole point of the tool. So it resolves the name through `workspace/symbol` first
+and asks again at that position. When a name exists in several places you get **the list** —
+it does not pick one and pretend.
+
+### It checks the file you just edited
+
+`Verify` stays too. They do different jobs.
+
+| | When | What |
+|---|---|---|
+| `Verify` | Once, before you finish | **Syntax** (`node --check`, `py_compile`) |
+| Post-edit diagnostics | Right after an edit, that file only | **Meaning** (undefined names, wrong types, missing arguments) |
+
+Some things are syntactically fine and still wrong. `node --check` passes all of them.
+
+```
+⏺ Write(pkg/bad.py)
+  3 lines
+  language server — pkg/bad.py: 2 errors
+    line 1 error: Type "Literal['x']" is not assignable to declared type "int"
+    line 2 error: "missing_name" is not defined
+```
+
+Until now that only showed up **once something was run**, and running goes through user
+approval, so it was several steps later. In between, the model treats that file as finished
+and moves to the next one. When the error finally surfaces you have to trace back, and
+tracing back costs more than the fix.
+
+When everything is fine it **says nothing.** A line of "0 errors" after every edit fills the
+window. And not receiving diagnostics is not the same as having none — when nothing came
+back, it says nothing rather than inventing an answer.
+
+### It installs nothing
+
+**deel does not install language servers.** It scans PATH; if one is there it uses it, and
+if not it falls back to `Grep` and `Outline`. This program exists for places where you cannot
+bring in unapproved software, so a tool running `npm i -g` on its own is out of the question.
+
+With no server, `Def` and `Refs` **do not appear in the model's tool list at all** — the same
+way web tools are hidden offline. Leave an unusable tool standing and the model calls it,
+gets "not available", and calls it again. That round trip costs more than the schema does.
+
+`/lsp` shows you what is there.
+
+```
+$ /lsp
+
+  ◈ 2 language server(s) on this machine
+     ✓ ts    typescript-language-server
+     ✓ py    pyright-langserver
+
+  Language of this folder: py · 12 files
+  Tools: Def · Refs
+  Diagnostics after an edit: on
+  Turn post-edit diagnostics on or off: /lsp on · /lsp off
+```
+
+It looks for `ts`, `py`, `go`, `rs`, `java`, `cs`, `cpp`, `rb`, `php` and `lua`. When one is
+missing it prints the install command **as text only.** Whether to run it is your call.
+
+<details>
+<summary>Four things a real server (pyright) taught us</summary>
+
+A stub server alone would have shown green for all of these.
+
+- **Servers spell URIs differently than we do.** We send `file:///C:/…`; pyright answers with
+  `file:///c%3A/…` — lowercase drive letter, percent-encoded colon. Compared as strings they
+  never match. Diagnostics arrive correctly, are not found in our table, and become "nothing
+  came back" — and **saying nothing means the file is sound**, so a broken file gets reported
+  as fine. We compare paths, not URIs.
+- **A server that just started answers empty.** Not because the name is missing but because
+  it has not finished indexing. Asked 0.2s after startup it said no; 0.5s later it said yes.
+  Turning that into "no such name" makes the model create something that already exists. So
+  it asks again a few times, but only while the server is young.
+- **npm installs two names on Windows.** An extension-less sh script and a `.cmd`. Find the
+  first one and the file plainly exists, so it reports "installed" — but Windows cannot run
+  it. Claiming it is there and then failing is the hardest failure to spot.
+- **`cmd /s /c` strips the outer pair of quotes.** Wrap the command once and it breaks
+  entirely, and all you see from the outside is "no language server".
+
+</details>
+
+</details>
+
 ---
 
 ## Korean text and Excel
 
+**A file saved as CP949 is written back as CP949.** The encoding is never changed.
+Excel (`.xlsx`) is read as CSV — read-only.
+
+<details>
+<summary><b>More</b> — Encoding · Excel</summary>
+
 ### Encoding — written back the way it was read
 
 Corporate documents are often not UTF-8. Files saved by old Windows Notepad in a legacy
@@ -1200,6 +1404,55 @@ Extracted intermediate files are deleted after use.
 > to do instead. Round-tripping a file with formatting, formulas and charts through CSV
 > always loses something. Better not to write than to write knowing you'll lose data.
 
+</details>
+
+---
+
+## Serving what you built
+
+```
+❯ /preview
+
+  ▶ Serving  http://127.0.0.1:56801/
+  showing .
+  Edit a file and the page reloads by itself.
+  Only this machine can open it (127.0.0.1). No other PC can see it.
+  Stop with /preview off  · it shuts down when deel exits.
+```
+
+A browser opens with it. `/preview <folder>` picks what to serve, `/preview off` stops it.
+
+**This is not the same as double-clicking the file (`file://`).** Under `file://` everything
+below is blocked — and the error only shows up in the console while the page stays blank, so
+you end up suspecting your own code. This is a real HTTP server, so it all works:
+
+| | `file://` | `/preview` |
+|---|---|---|
+| `<script type="module">` · `import` | blocked (CORS) | **works** |
+| `fetch('./data.json')` | blocked | **works** |
+| `new Worker(...)` | blocked | **works** |
+| `WebAssembly.compileStreaming` | blocked (MIME) | **works** |
+| textures · `getImageData` | tainted canvas | **works** |
+| `.glb` / `.gltf` (Three.js) | no MIME type → silently not drawn | **works** |
+
+All seven were run in a real Chrome and confirmed **7/7**.
+
+Apps with a router (React Router and friends) get the first page back when you reload on a
+deep link. Never for requests with an extension (`app.js`) though — returning HTML for a
+missing script dies with `Unexpected token '<'`, which hides the real cause (a typo in a filename).
+
+### It opens exactly as much as it says
+
+Starting a server means opening your disk to somebody else.
+
+- Bound to **`127.0.0.1` only**. `0.0.0.0` is not available at all — on an office network
+  that would let anyone read your source.
+- Port **0** (the kernel hands out a free one). A fixed port steals someone else's.
+- Paths cannot leave the working scope. `../` · `%2e%2e` · double encoding · absolute paths ·
+  null bytes · symlinks — eight of these are held shut by tests.
+- **It only serves.** `POST` · `PUT` · `DELETE` are refused with 405.
+- It shuts down when `deel` exits.
+
 ---
 
 ## Skills and plugins
@@ -1215,6 +1468,9 @@ plugins  ~/.claude/plugins/**   ~/.deel/plugins/**
 
 Reads the Claude Code format: `SKILL.md` with YAML front matter, `commands/*.md`, `$ARGUMENTS`.
 
+<details>
+<summary><b>More</b> — Loaded in three stages · Fetching plugins · Deliberately not included</summary>
+
 ### Loaded in three stages
 
 Loading everything would blow the context window.
@@ -1247,6 +1503,8 @@ with a licence table — ready to hand to a security reviewer.
 | sub-agents | Doubles model calls against a gateway quota |
 | MCP | A separate protocol; a project of its own |
 
+</details>
+
 ---
 
 ## Reasoning effort
@@ -1295,6 +1553,9 @@ That second-to-last line exists for a reason: **when all three caps are equal, i
 only thing that says whether that is correct.** A low known cap makes them equal, and that
 is fine. For a while all three read `16,384` always — which meant the table said nothing.
 
+<details>
+<summary><b>More</b> — Context length is read off the model · /out · Truncated tool calls</summary>
+
 ### Context length is read off the model
 
 This one number sizes the whole program: how many files fit in one read, when the
@@ -1428,6 +1689,8 @@ One silently swallowed value produced all of that. What happens now:
 spinning one. What is counted here is not steps but **how many times the same tool failed for
 the same reason.**
 
+</details>
+
 ---
 
 ## Auto-compaction
@@ -1495,6 +1758,9 @@ The model sees it as `mcp__wiki__search`. `/mcp` shows what is attached.
 **Dependencies stay at zero.** The stdio transport is nothing but newline-delimited JSON-RPC
 2.0 over a child process's stdin/stdout, so `child_process` and `JSON` cover it. No SDK.
 
+<details>
+<summary><b>More</b> — But this is somebody else's program</summary>
+
 ### But this is somebody else's program
 
 This project exists because unapproved software is blocked. Turning on MCP carelessly would
@@ -1514,6 +1780,110 @@ One server crashing, hanging, or talking nonsense does not affect the others. Fa
 swallowed — the reason appears in the header, because a silent drop leaves "why is that tool
 missing?" unanswerable.
 
+</details>
+
+---
+
+## Inside your editor (ACP)
+
+A tool that makes you open one more terminal window stops being used after about two weeks.
+Developers live inside the IDE. So deel speaks **ACP** (Agent Client Protocol) — Zed,
+JetBrains, Neovim and Emacs attach to it **without changing a line on their side**.
+
+One command in your editor's settings:
+
+```
+deel acp
+```
+
+The editor spawns that as a child process and exchanges newline-delimited JSON-RPC 2.0 over
+stdio. It is not a command you type yourself.
+
+**What you get once it is attached:**
+
+| In the editor | From deel |
+|---|---|
+| Streaming reply pane | The model's text and its reasoning |
+| Tool list with icons and status | `Read` is a read, `Edit` is an edit, `Bash` is an execution — **the kind is sent**, not just a name |
+| Clickable file links | The **absolute path** of every file touched |
+| Approval dialog | deel's safety rails, rendered as the editor's own prompt (`allow once` · `always allow` · `reject`) |
+| Mode picker | deel's seven work modes (auto · code · plan · architect · debug · ask · orchestrator) |
+| Stop button | Reaches the turn mid-flight, even while waiting on the model |
+
+**Still zero dependencies.** Same reason as MCP — newline-delimited JSON-RPC 2.0 is the whole
+transport, so no SDK is needed.
+
+<details>
+<summary><b>Details</b> — the places this breaks silently</summary>
+
+This protocol fails quietly. The editor shows "the agent is not responding" and nothing
+anywhere explains why. So these are nailed down by tests (`test/acp.test.js` spawns a real
+process and talks over a real pipe).
+
+| The place | Why it matters |
+|---|---|
+| **Nothing but ACP on stdout** | The spec says `MUST NOT`. deel has dozens of places that print to the screen; one of them firing in this mode breaks the pipe. Rather than guarding each call site, **the pipe itself is swapped out** — so code written later is safe without knowing about this. What gets printed is not dropped, it goes to stderr |
+| **Korean split across chunk boundaries** | Pipes break on bytes, not characters. Decoding each chunk separately turns `안녕` into `안<?>하` — and **the JSON still parses**, so no error is raised. The characters are quietly mangled |
+| **A request with `id: 0`** | ACP clients count from zero. Reading `if (msg.id)` treats the very first `initialize` as a notification and never answers — it hangs the moment it connects |
+| **Cancellation reaching a running turn** | Cancellation always arrives while something is running; that is what cancellation is. Awaiting each incoming line in order means it **never arrives** |
+| **When permission cannot be asked** | It is tempting to just run the tool — otherwise nothing works against a client that has not built the approval dialog yet. But that means "if I can't ask, I do as I please". **It does not** |
+
+**What it does not do yet, stated plainly:**
+
+| | |
+|---|---|
+| `session/load` | Restoring a past conversation means replaying every message as an update. Half-built, the editor opens an empty conversation and the user assumes the history is gone. It reports **`loadSession: false`** |
+| Image / audio attachments | Most local models cannot read them. Rather than dropping them silently, deel tells the model what it could not read |
+| MCP servers passed in by the editor | Not launched. That would mean **deel spawning processes named in the editor's config**. "What does this tool launch?" is the first question in a corporate review, and "whatever the editor says" is not an acceptable answer. Only `.deel/mcp.json`, written by a person, is launched |
+
+</details>
+
+---
+
+## Keeping secrets out of the conversation
+
+People rarely paste a key. The leak is almost always **command output**.
+
+```
+env                  OPENAI_API_KEY=sk-proj-…
+git remote -v        https://user:token@github.com/…
+curl -v              > Authorization: Bearer eyJ…
+a failing test log   the whole connection string
+```
+
+That text goes to the model **and** gets written to `.deel/sessions/*.jsonl` on disk. That
+file is later re-read by `/recall` and can end up inside a `deel pack` bundle. Leak once and
+you have several copies.
+
+So it is masked at the single point where tool output enters the conversation.
+
+```
+  ⏺ Bash(env | grep API)  done
+    ⊘ 2 secret-looking values entered the conversation (openai · env var) — masked before the model
+```
+
+What it looks for: private-key blocks · OpenAI/Anthropic keys · GitHub tokens · Slack tokens ·
+AWS keys · Google keys · JWTs · credentials embedded in URLs · `Authorization`-family headers ·
+env vars named `…KEY` / `…TOKEN` / `…SECRET` / `…PASSWORD`. Plus **the configured gateway key
+regardless of its shape** — that one is not a guess, it is a known value.
+
+### File contents are deliberately not masked
+
+`.env` is exactly where masking feels most tempting, and exactly where it backfires: the model
+sees the masked text, edits it, writes it back — and `«가림»` lands where the real key was.
+**Protecting the secret would destroy it.**
+
+So on the file side it reports instead of rewriting.
+
+```
+  ⏺ Read(.env)  12 lines
+    ! 3 secret-looking values entered the conversation (env var)
+      — file contents are not masked (masking them would erase the key on write-back)
+```
+
+Saying plainly what cannot be stopped beats claiming it was stopped while corrupting the file.
+Either way it lands in the audit log.
+
 ---
 
 ## Safety
@@ -1543,6 +1913,9 @@ Undo history stores whole file contents, so repeated edits to large files add up
 it keeps the **most recent 50 turns** and drops the rest. What you just did is always
 undoable; `/status` shows how large the history currently is.
 
+<details>
+<summary><b>More</b> — Files removed through Bash come back too · What it will not read</summary>
+
 ### Files removed through `Bash` come back too
 
 The safety net covered `Write` and `Edit` only. But a model moving a file reaches for
@@ -1611,6 +1984,8 @@ the read guard look at the same set. They used to be two copies, and two copies
 comes when only one of them learns a new name — a folder that is skipped while walking but
 readable if you name it directly, which is very hard to explain.
 
+</details>
+
 ---
 
 ## Corporate review package
@@ -1621,25 +1996,39 @@ deel pack --out deel-import.zip
 
 ```
   ✓ deel-import.zip
-     39 files · 100.2KB
+     94 files · 509.6KB
 
   Dependencies      0
   Install scripts   none
   External imports  0
   Network calls     3 sites (configured address only)
-  Ports opened      none
+  Ports opened      1 site (/preview only)
 ```
 
-The bundled review sheet contains:
+The zip carries **one document for people and two for machines.** A corporate review is
+not a human-only process — security feeds an SBOM to a scanner, and operations reads the
+audit-log spec to write SIEM ingestion rules.
+
+| File | What |
+|---|---|
+| `반입심사서.txt` | Dependencies · install scripts · **every network and process-spawn call site found by scanning the source** (file:line) · the three outbound lanes · SHA-256 per file |
+| `sbom.cdx.json` | **SBOM (CycloneDX 1.5).** Feed it straight to a scanner. One component per file with SHA-256; dependencies stated as an **explicit empty array** — "not declared" and "none" are different claims |
+| `심사명세.json` | Egress list (per lane: when, where, what, how it's stopped, and the source location) · **audit-log spec** (field names and meanings, plus what is never recorded) · file hashes |
+
+```bash
+deel audit                    # the human-readable sheet only
+deel sbom                     # the two machine-readable ones, on stdout (deel sbom | jq)
+deel sbom --out review.json   # to a file
+deel sbom --only sbom         # just the SBOM
+```
 
-- Dependency list and every external `import` in the source
-- Presence of `preinstall` / `install` / `postinstall` / `prepare`
-- **Every network and process-spawn call site found by scanning the source** (file:line)
-- The three outbound lanes, explained
-- SHA-256 per file (verify with `certutil -hashfile`)
+All three are generated by scanning the source, never written by hand — hand-written sheets
+drift, and **a review document that drifts is worse than none.** Find one wrong line and the
+reviewer stops trusting the rest. The audit-log spec is the one hand-written part, so a test
+checks it against real log records on every run.
 
-It is generated by scanning the source, not written by hand — hand-written sheets drift from reality.
-Use `deel audit` to read it without building a zip.
+<details>
+<summary><b>More</b> — Diagnosing a corporate gateway</summary>
 
 ### Diagnosing a corporate gateway
 
@@ -1662,12 +2051,17 @@ Hand over `report.txt` alone — plain text, no colour codes.
 
 Verdict is one of **ready · limited · blocked · unreachable**.
 
+</details>
+
 ---
 
 ## Configuration
 
 Stored in `~/.deel/config.json`. A `.deel/config.json` in the project folder takes precedence.
 
+<details>
+<summary><b>More</b> — Supported servers · Environment variables · Flags · Project rules</summary>
+
 ### Supported servers
 
 | | Example address |
@@ -1712,6 +2106,8 @@ deel --no-tui            Turn the input box off; plain scrolling view (see below
 If the working folder has `DEEL.md`, `CLAUDE.md` or `AGENTS.md`, it is loaded as project rules.
 `/init` scaffolds one.
 
+</details>
+
 ---
 
 ## Troubleshooting
@@ -1777,6 +2173,9 @@ so one run tells you everything.
 | `no-bundle` | 12 | Nothing foreign in the published package; test-file hygiene |
 | `edit-bench` | 20 cases | Edit success rate |
 
+<details>
+<summary><b>More</b> — Coverage · Layout</summary>
+
 ### Coverage
 
 ```bash
@@ -1797,6 +2196,414 @@ Currently **92% overall** (7,056 of 7,646 lines). Three files are deliberately l
 | `repl.js` | 77% | The keypress paths — Shift+Tab, Ctrl+C, password entry, paste. Reaching them needs a pty, and a pty is a dependency. What the screen *prints* is measured instead, as a value (`ui` and `tui` suites) |
 | `plugins/manage.js` | 79% | The GitHub download path. **Tests not reaching the network** matters more. Folder installs are covered |
 
+### Layout
+
+```
+bin/deel.js              entry point
+src/
+  repl.js                the conversation screen — what a person faces
+  oneshot.js             run once and exit (-p)
+  commands.js            35 slash commands
+  setup.js               first-run connection setup
+  config.js              reading and writing config
+
+  ui/ansi.js             colour · East Asian width
+  ui/screen.js           picking a screen (line mode / box mode)
+  ui/inputbox.js         the box at the bottom — overwrite-in-place, cursor position
+  ui/status.js           status line — model, context, mode, approvals
+  ui/working.js          working phrases — they follow what is happening
+  ui/motion.js           the braille drawing next to the phrase
+  ui/approve.js          approval mode display (auto / risky only / everything)
+  ui/diff.js             showing what changed, where it changed
+  ui/wrap.js             wrapping to width without breaking colour
+  ui/level.js            simple vs developer
+
+  agent/loop.js          the agent loop
+  agent/session.js       conversation state + context accounting
+  agent/modes.js         work modes (auto · code · plan · architect · debug · ask · orchestrator)
+  agent/route.js         picking the mode from what was said
+  agent/effort.js        per-stage reasoning effort
+  agent/budget.js        shares that follow the window — lines read, description length, steps
+  agent/project.js       working out what kind of project this folder is
+  agent/compact.js       summarising compaction
+  agent/store.js         saving and resuming conversations
+  agent/recall.js        searching past conversations (no index, within budget)
+  agent/memory.js        what outlives the conversation
+  agent/mention.js       attaching files with `@`
+
+  backend/http.js        the single HTTP layer (the only door out)
+  backend/detect.js      protocol and auth detection
+  backend/adapter.js     absorbing OpenAI/Ollama differences + streaming parser
+  backend/ctxsize.js     reading context length off the model
+  backend/probe.js       8 diagnostic checks
+  backend/scan.js        scanning for local servers
+  backend/mcp.js         attaching outside tools (MCP, stdio)
+
+  tools/index.js         17 tools
+  tools/edit-match.js    staged-relaxation edit matching
+  tools/outline.js       a file's shape, cheaply
+  tools/verify.js        checking what was built
+  tools/task.js          splitting big work off
+  tools/jobs.js          commands that run in the background
+  tools/todo.js          checklists
+  tools/webfetch.js      reading the web (read-only)
+  tools/encoding.js      writing back in the encoding it was read in
+  tools/xlsx.js          Excel → CSV (written here)
+  tools/lsp.js           Def · Refs — asking the language server
+
+  lsp/rpc.js             LSP framing (Content-Length + JSON-RPC, written here)
+  lsp/servers.js         finding installed language servers (installs nothing)
+  lsp/client.js          one server: spawn, talk, time out, clean up
+  lsp/diag.js            is the file you just edited sound?
+
+  preview/serve.js       serving what you built (127.0.0.1 only)
+  skills/discover.js     finding skills, commands and plugins on the machine
+  plugins/manage.js      installing, removing and packing plugins
+  pack/zip.js            ZIP writing (written here, keeps non-ASCII names)
+  pack/tar.js            TAR reading (written here)
+  pack/selfpack.js       review dossier + source bundle
+
+  safety/network.js      the lock on the way out
+  safety/guard.js        working scope + dangerous-command blocking
+  safety/undo.js         snapshots and undo
+  safety/audit.js        recording what happened, and when
+test/                    tests (excluded from the published package)
+```
+
+</details>
+
+---
+
+## Release notes
+
+<details>
+<summary><b>▸ 1.4.0 — deel gets a face, speaks English, and sees meaning</b> · what changed in seven places</summary>
+
+<br>
+
+| | Before | After |
+|---|---|---|
+| `/undo` | rolled back files only — the conversation still believed it happened | rewinds **the conversation too** |
+| Turns that take minutes | you sat watching the screen | a bell and the window title — you can be in another window |
+| Startup · status bar | looked like any other CLI | letters that grow on start, a status bar that names the boundary |
+| English speakers | the screen was all unreadable | `/lang en` — the screen **and what the model reads** |
+| Models per session | one | a different model per chunk — routine work to a small one |
+| Finding a name | `Grep` only — comments and strings mixed in | `Def` / `Refs` — by **meaning**, when a server is installed |
+| A file you just edited | you found out by running it | checked **right after** the edit, that file only |
+
+<br>
+
+#### 1. `/undo` rewinds the conversation
+
+Roll back only the files and the conversation still holds the edit. The model believes it
+just changed that file and builds the next step on top — and nothing on screen says
+otherwise. Now the messages fold back with the files. Folding can orphan a tool call, which
+the server answers with a 400, so the same `repairToolPairs` runs over the result.
+
+#### 2. It tells you when it is done — `/bell`
+
+A local model can take minutes per turn. A bell and the window title say when it finishes.
+The bell is ``, but **not one byte reaches a pipe** — with no TTY it writes nowhere. The
+title ends with ST, not BEL; ending with BEL rings the bell on every title update.
+
+#### 3. A screen that is deel's own
+
+On start, `deel` grows into `deel-local`. The status bar names the boundary you are inside
+with one glyph (`⌂` this folder · `↗` outside · `?` unknown). The animation uses braille and
+box-drawing only — emoji and geometric shapes are East Asian Ambiguous, so their width
+varies per terminal and the line drifts by a column.
+
+#### 4·5. English on screen, and in what the model reads
+
+`/lang en` switches the screen. Untranslated strings come through in Korean rather than as
+blanks, and `/lang` counts honestly how many are left.
+
+But switching only the screen leaves the model answering in Korean — its rules say to. So
+what the model reads switches too (base rules, mode instructions, all sixteen tool
+descriptions). There is a bonus: Korean costs about one token per character and English
+about one per 3.6, so the fixed share of a 32k window dropped from **4,910 to 3,446 tokens.**
+
+Tool names and argument names are **not** translated. Those are identifiers.
+
+#### 6. Several models in one session — `Task`'s `모델`
+
+A large model and a small one, together, on 8GB of RAM. Routine work (formatting, repetitive
+edits, short summaries) goes to the small one; you keep what needs judgement. The subtask's
+endpoint opens through `allowTemporarily` and **always closes in `finally`** — afterwards
+exactly one endpoint is open again.
+
+#### 7. Language servers — `Def`, `Refs`, post-edit diagnostics
+
+See "With a language server, it sees meaning" above. **It installs nothing.**
+
+</details>
+
+<details>
+<summary><b>▸ 1.3.0 — evidence instead of claims, the editor instead of a terminal</b> · what changed in six places</summary>
+
+<br>
+
+| | Before | After |
+|---|---|---|
+| Rules that must hold | **vanished** when folded or summarised | live outside the message list, where folding cannot reach |
+| This model's habits | the prompt **asked** it to behave | the harness changes instead — no cooperation needed |
+| Finishing | "all done" | what changed, and what proves it. **Including what doesn't** |
+| Where you use it | one more terminal window | inside your editor (Zed · JetBrains · Neovim · Emacs) |
+| Review paperwork | one document, for humans | SBOM · egress list · audit spec — **straight into a scanner** |
+| Keys | one `env` and they were in the conversation and on disk | masked where output enters. Files are **deliberately** left alone |
+
+<br>
+
+#### 1. Rules that must hold were vanishing into the fold — `/pin`
+
+Long conversations fold and summarise earlier turns to make room. A 2026 measurement found
+**summarisation preserves only about 50% of safety constraints.** If "never touch this
+folder" lands in the missing half, the model is in a state where it was never told. Nothing
+appears on screen.
+
+Pinned lines are **not kept with the messages.** They are appended to the end of the system
+prompt — and since folding and compaction only touch messages, they are structurally out of
+reach. Not carefully preserved: **impossible to remove.**
+
+```
+/pin never touch src/legacy
+
+  ✓ Pinned — 2 now (78 tokens)
+```
+
+Up to 12 lines / 240 tokens. Past that it says so and carries the most recent — dropping
+them quietly would defeat the point of pinning.
+
+#### 2. Observed habits stayed as words — `/model 카드`
+
+deel already watched what the model did. But watching was all it did — it **wrote advice
+into the prompt**: "you keep truncating arguments, use Append." Small models don't follow
+that advice. That is what makes them small models.
+
+Now what it observes becomes **harness settings**. Instead of asking the model, deel changes
+its own behaviour.
+
+| Observed | What changes |
+|---|---|
+| Arguments truncate often (over 15%) | The cap is raised up front — no wasted first call |
+| It repeats itself | Three identical calls tolerated becomes two |
+| Edits miss often | More surrounding lines are shown on a near-miss |
+
+**Nothing changes before 12 steps.** Pinning down a healthy model because of one unlucky
+truncation is worse than not learning at all.
+
+#### 3. Evidence instead of "all done" — `/evidence`
+
+A 2026 survey found **96% of developers don't fully trust AI-written code, while 48% verify
+it every time.** 38% said it is harder to review than human code.
+
+Why harder? Ask a person why they wrote it that way and you get an answer. Agent-written
+code arrives with **one line: "done."** That line cannot be reviewed.
+
+```
+/evidence
+
+  Changed         3 files · +142 −38
+  Ran             5 commands (1 failed)
+  Unproven        1
+
+  ✗ src/worker.js — the last `npm test` failed — an earlier pass
+                    does not prove the current state.
+```
+
+Listing what changed is something `/diff` already does. What only this does is **say that
+the unproven is unproven.** Three things get caught —
+
+- Changed something and ran nothing? Nothing was proven
+- Counting a red test as green means **offering a failing test as evidence**
+- A check run *before* the edit proves nothing about it — "I ran it earlier" is the most
+  common form of self-deception
+
+If the build passed and the tests broke *after* it, the earlier green is not evidence. The
+last thing you ran is red; it cannot have been verified.
+
+`/evidence filename` writes it as markdown under `.deel/증거/`. The screen scrolls away, and
+the review happens later, by someone else.
+
+#### 4. It made you open one more terminal — `deel acp`
+
+Developers live inside the IDE. A tool that makes you switch windows stops being used after
+about two weeks. A build that cleared corporate review and then nobody uses is the saddest
+possible outcome.
+
+deel now speaks **ACP** (Agent Client Protocol). One line — `deel acp` — in your editor's
+settings and Zed, JetBrains, Neovim and Emacs attach **without changing a line on their side**.
+
+The work isn't connecting the pipe; it is **making the editor able to show something**.
+Kind, location and status are all optional in the spec, so a quick implementation omits all
+three — and then every tool is the same grey dot and no changed file is clickable.
+
+Approval flows through too. deel's safety rails render as the editor's own dialog, and
+"always allow" is remembered for that session. Against a client that cannot ask, it
+**does not run** — "if I can't ask, I do as I please" is not an option.
+
+**Still zero dependencies.** Newline-delimited JSON-RPC 2.0 is the whole transport, so no SDK.
+
+#### 5. Review paperwork only a human could read — `deel sbom`
+
+A Korean financial-sector rule change on 2026-04-20 opened an exemption to the network-
+separation mandate. The paperwork demanded at that door is not prose — security feeds an
+**SBOM to a scanner** for a vulnerability list, and operations reads the audit-log spec to
+write SIEM ingestion rules.
+
+`deel pack` now emits three documents.
+
+| | |
+|---|---|
+| `반입심사서.txt` | The human-readable sheet, as before |
+| `sbom.cdx.json` | CycloneDX 1.5. One component per file with SHA-256. Dependencies as an **explicit empty array** — "not declared" and "none" are different claims |
+| `심사명세.json` | Egress list (per lane: when, where, what, how it's stopped, source location) · audit-log spec · file hashes |
+
+All three are generated by scanning the source. The audit-log spec is the one hand-written
+part, so **a test compares it against real log records on every run** — a review document
+that drifts is worse than none, and one wrong line costs you the reviewer's trust in the rest.
+
+#### 6. One `env` put your keys in the conversation and on disk
+
+People rarely paste a key. The leak is almost always command output — `env`, `git remote -v`,
+`curl -v`, a failing test log. That text goes to the model **and** is written to
+`.deel/sessions/*.jsonl`. Leak once, and you have several copies.
+
+Masking now happens at the single point where tool output enters the conversation:
+private-key blocks, OpenAI, Anthropic, GitHub, Slack, AWS, Google, JWTs, credentials in URLs,
+`Authorization`-family headers, and env vars named `…KEY` / `…TOKEN` / `…SECRET` /
+`…PASSWORD`. The configured gateway key is removed regardless of shape — that one is a known
+value, not a guess.
+
+**File contents are deliberately not masked.** Mask `.env` and the model edits the masked text
+and writes it back, landing a placeholder where the real key was — protecting the secret would
+destroy it. So on the file side it reports instead of rewriting.
+
+<br>
+
+Tests 2,578 → **2,860** · 54/54 files. Earlier releases are on the [tags](https://github.com/jysvai/deel-local-cli/tags) page.
+
+</details>
+
+<details>
+<summary><b>▸ 1.2.0 — so the conversation doesn't break</b> · what changed in six places</summary>
+
+<br>
+
+| | Before | After |
+|---|---|---|
+| Resuming | a conversation cut mid-tool-call **would not reopen** | unmatched calls are cleared, then it opens |
+| Counting tokens | it guessed, and stayed wrong | it corrects itself against the server |
+| Making room | summarising arrived at turn 49 | it holds out to turn **102** |
+| Side questions | piled up in the main context | live in their own thread |
+| Yesterday's lesson | vanished when you quit | carries over to the next session |
+| The answer on screen | `**bold**` showed up as characters | it is drawn |
+
+<br>
+
+#### 1. A conversation cut mid-tool-call would not reopen
+
+Close the window or hit <kbd>Ctrl</kbd>+<kbd>C</kbd> while a tool is running and the saved conversation keeps **a call with no result under it**. Reopen it with `--resume` and the server rejects the mismatch with a 400 — the conversation was written down perfectly well, and you still could not carry on.
+
+Now the pairs are checked before it opens. Calls with no result go, results with no parent go, and **whatever the model said stays.**
+
+```
+$ deel --resume 20260826-140217
+
+  ✓ 20260826-140217 — 메시지 48개를 이어 받았습니다.
+  중단된 도구 호출 2개를 걷어냈습니다 — 그때 하던 일은 다시 시켜 주세요.
+```
+
+#### 2. It misjudged the room left
+
+Token counts are estimated from character counts. Mix Korean, code and JSON and that estimate drifts from the truth — so deel folded early with room to spare, or did not fold when there was none and the server refused.
+
+It now **corrects the multiplier against what the server actually reports** with every answer. One line at the foot of `/context`:
+
+```
+  서버가 알려 준 실제값에 맞춰 +12% 보정했습니다 (7번 재봄).
+```
+
+The multiplier is kept per model, so **the next session starts from it** instead of measuring again from scratch.
+
+#### 3. Summarising arrived too early
+
+At 80% of the window, earlier turns get folded into a summary. That **cannot be undone**, and the file contents the reasoning rested on are gone with it.
+
+There is now a step before it. At 55%, **only older tool results** are folded — the four most recent are left alone, and nothing the model or you said is touched at all.
+
+```
+  ◲ 오래된 도구 결과 6개를 접었습니다 (2,148 토큰을 비움)
+```
+
+What was there is left in its place:
+
+```
+  (접힘) Read(src/runner.js) — 61줄. 자리를 비우려고 내용을 접었습니다. 필요하면 다시 읽으세요.
+```
+
+Measured by streaming the same conversation through: summarising is pushed from **turn 49 to turn 102 — 2.1×**.
+
+#### 4. Side questions polluted the main line
+
+"Just check this one thing" piles into the main context and stays there long after the checking is done.
+
+```
+/thread new 로그확인
+  ⑂ 로그확인 갈래로 왔습니다. 빈 대화입니다
+  본줄기로 돌아가려면 /thread 1
+```
+
+`fork` carries the conversation so far with you. What threads **keep apart is the messages, the token count and the checklist**; what they **share is the connection, undo and the audit log** — a file changed inside a thread still comes back with `/undo`. The `⑂` marker appears in the status line only once there is more than one thread.
+
+#### 5. Yesterday's lesson vanished when you quit
+
+deel could work out that `pnpm` is not on this machine, and lose it the moment you quit. Tomorrow it calls it again, fails again, works around it again.
+
+```
+/learned
+── 겪어 본 것 ──────────────────────────────────────
+
+  이 폴더에서 돌려 본 명령
+    ✓ npm test                 됨 12 · 안 됨 0
+    ✗ pnpm                     됨 0 · 안 됨 3
+
+  이 모델에 대해  qwen2.5-coder:7b
+    같이 걸어 본 걸음             86
+    인자가 잘림                   14  (16%)
+    토큰 추정 보정             ×1.12
+
+  이 중 프롬프트에 실리는 것
+  - 여기서 되는 명령: `npm test`
+  - 이 PC 에서 안 되는 명령(다시 부르지 마라): `pnpm`
+```
+
+**This is not training.** It does not touch the model and it does not hoard conversations — that would only eat context. It counts, and it carries over **only what it has seen twice**, all of it **within 220 tokens**. Something seen once may be a coincidence, and writing a coincidence down as fact sends the model around a road that actually works.
+
+Commands that work live with the folder (`.deel/배운것.json`); the model's habits live in the config folder. So **move the folder and what it learned about the model comes along.** `/learned 지우기` empties it whenever you want.
+
+#### 6. The answer showed up as raw characters
+
+The model speaks Markdown and the screen did not know it, so asterisks, backticks and hashes came through mixed into the prose. You had to re-read it in your head to see what was a heading and what was code.
+
+```
+before                                 after
+▌ ## 고친 것                           ▌ ▍ 고친 것
+▌ **src/runner.js** 의 `console.log`   ▌ src/runner.js 의 console.log
+▌ - [ ] 남은 것: `src/worker.js`       ▌ ☐ 남은 것: src/worker.js
+▌ ```js                                ▌ ┌──────────────── js
+▌ log.info('시작', { id })             ▌ │ log.info('시작', { id })
+▌ |---|---|                            ▌ ┼────────┼─────────┼
+```
+
+Answers arrive in fragments, so a line can only be drawn **once it ends**. But a whole paragraph on one line would leave the screen still for seconds — so once a line grows past the screen width, everything up to there is **streamed raw**. Looking alive comes before looking neat.
+
+<br>
+
+Tests 2,532 → **2,578** · 48/48 files. Earlier releases are in the [tags](https://github.com/jysvai/deel-local-cli/tags).
+
+</details>
+
 ---
 
 ## Licence