Skip to content
Back to search

anvil.el

An MCP server written in Elisp — a token-efficient workbench for AI agents. Drives files, org-mode, Elisp & SQLite from any MCP client (Claude, GPT, local LLMs) through Emacs primitives instead of sed/grep round-trips.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/zawatton/anvil.el with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/zawatton/anvil.el'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zawatton--anvil-el/badge.svg)](/listings/zawatton--anvil-el)

HTML

<a href="/listings/zawatton--anvil-el"><img src="/api/listings/zawatton--anvil-el/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.org · README · 1,747 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. #+title: anvil.el — token-efficient MCP toolkit for AI agents
  2. #+author: zawatton
  3. *Languages:* English / [[file:README.ja.org][日本語]]
  4. #+begin_quote
  5. *Note on language:* I'm a non-native English speaker. The phrasing in
  6. this README is shaped with help from an LLM, but the thinking and the
  7. design decisions are entirely mine. The LLM is acting as a translator
  8. / editor, not the author. If something reads oddly, please read it
  9. with that in mind.
  10. #+end_quote
  11. #+html: <a href="https://github.com/zawatton/anvil.el/actions"><img src="https://img.shields.io/github/actions/workflow/status/zawatton/anvil.el/ci.yml?branch=master&style=flat-square" alt="CI"></a>
  12. #+html: <a href="https://github.com/sponsors/zawatton"><img src="https://img.shields.io/badge/Sponsor_%E2%9D%A4_Support_this_project-pink?style=for-the-badge" alt="Sponsor"></a>
  13. * TL;DR
  14. anvil.el is a workbench for AI agents. Optional modules (memory / orchestrator / session / http / …) each add their own tools when you enable them.
  15. Claude Code, Codex CLI, Claude Desktop, GPT, local LLMs via Ollama — anything
  16. that speaks [[https://modelcontextprotocol.io/][Model Context Protocol]] can edit files, navigate org-mode,
  17. run elisp, query SQLite, and more *through Emacs primitives* instead
  18. of generic =sed= / =grep= / =read-whole-file= round-trips. That
  19. swap is where the token savings come from.
  20. v1.4.1 (2026-10-04) adds bounded handling for
  21. selected file reads and successful inline results, bounded diagnostic and
  22. telemetry traversal, and safer worker cleanup after successful termination.
  23. These changes build on the v1.4.0 feature set: searchable Claude Code session
  24. events and PreCompact reference snapshots, in-place memory updates, stateless
  25. MCP requests, worker deadlines, a NeLisp v1.2.0 standalone path, and expanded
  26. fusion capabilities. The Emacs daemon remains the full-featured path.
  27. v1.4.0 brought the develop line through 2026-10-03 to =master=. It adds
  28. searchable Claude Code session events and PreCompact reference
  29. snapshots, in-place memory updates, stateless MCP requests, worker
  30. deadlines and timeout cleanup, and a NeLisp v1.2.0 standalone path
  31. with a TCP daemon and optional database-backed tools. Fusion gains
  32. Sonnet-solo, multi-round critique, and calibration reports that propose
  33. changes for review.
  34. The v1.3.0 mail, CAD, code graph, and context tools remain available;
  35. the Emacs daemon remains the full-featured path.
  36. [[file:STORY.org][STORY.org]] ([[file:STORY.ja.org][日本語]]) tells the longer "why this exists" story.
  37. * Current Release Highlights
  38. Release v1.4.1 (2026-10-04) adds bounded handling for file reads, successful inline results,
  39. diagnostic snapshots, and telemetry rendering, plus safer worker cleanup.
  40. The byte limits apply at their documented boundaries; they do not bound
  41. arbitrary execution or complete transport frames. The v1.4.0 feature baseline
  42. and July master wave remain available below.
  43. | Area | What changed |
  44. |------+--------------|
  45. | File reads | Default 1 MiB cap on selected raw bytes; pagination reads bounded chunks. Nil or non-positive legacy settings retain prior behavior. |
  46. | Inline results | Default 2 MiB budget for projected escaped UTF-8 JSON-string bytes on normalized successful results, checked before and after disclosure. Execution, result construction, error paths, and full frames are outside this limit. |
  47. | Diagnostics and telemetry | Finite traversal, depth, and leaf budgets apply before formatting. Raw tool-error snapshots are shared with telemetry; ordinary codes and metrics are preserved. Other error and transport paths are not all bounded. |
  48. | Worker cleanup | After a successful kill request, all identically owned slots are detached synchronously, without waiting for the sentinel. Kill errors preserve ownership; raw-response and pool diagnostics are retained. |
  49. For larger file reads, pass =offset="0"= and =limit="200"=, reducing the limit
  50. if the selected page is too large. Use paginated, filtered, tee, or asynchronous
  51. interfaces for larger results. Set =anvil-file-max-inline-read-bytes= or
  52. =anvil-server-max-inline-result-bytes= to nil or a non-positive integer only
  53. to restore the corresponding legacy behavior; other error and transport paths
  54. are not all bounded.
  55. Previous release: v1.4.0 includes the July master wave and the subsequent
  56. develop work through 2026-10-03. The July fusion guide is at
  57. [[file:docs/FUSION-GUIDE.org][docs/FUSION-GUIDE.org]]. New develop additions include:
  58. | Area | What changed |
  59. |------+--------------|
  60. | Session recall | When enabled, =session-events-search-ranked= searches Claude Code events indexed with FTS5 and a CJK fallback (for example, ={"query":"release","limit":5}=). Hooks merge safely, and PreCompact can retain a reference snapshot for restoration. |
  61. | NeLisp runtime | The standalone launcher follows NeLisp v1.2.0, supports NDJSON and Content-Length MCP framing, cache prewarming, and a TCP loopback daemon. It requires matching NeLisp and =nelisp-emacs-lib= revisions; SQLite-backed tools also need the dynamic reader. Windows TCP and macOS standalone operation are unverified. |
  62. | MCP and memory | The server accepts the 2026-07-28 stateless request form alongside initialize-based clients. Memory adds in-place updates and transactional scan handling. |
  63. | Worker and process control | Workers share a deadline budget; stdio process groups are cleaned up on timeout. Evaluation results and errors are bounded before returning to clients. |
  64. | Fusion | Adds Sonnet-solo panels, agentic member permission passthrough, deeper multi-round critique, and router calibration reports that propose changes without applying them. |
  65. | Mail and CAD | Wanderlust adds OAuth, Graph sync, and local filters; CAD adds standalone SVG fast paths and native file I/O. |
  66. The July master wave, also included in this release:
  67. | Area | What changed |
  68. |------+--------------|
  69. | Verifier-grounded fusion | =anvil-fusion-verify= extracts contested claims from panel answers, checks them against a local KB (grep evidence + adversarial skeptic vote + mechanical checkers), and feeds verdicts to a judge that may not adopt refuted claims. Acceptance run: 0/10 hallucination adoptions; hard-task gold recall 79% (single) → 100% (fusion+verify). |
  70. | Cascade router | =anvil-fusion-route-ask= answers once, risk-probes its own answer with a haiku-tier call, and escalates to panels only when risky — the 4-8x fusion multiplier is paid deliberately, not by default. |
  71. | Execution verification | =anvil-fusion-exec= runs each candidate code patch in a disposable git worktree and gates on a check command; failing candidates are excluded from synthesis. |
  72. | Plan fusion + agentic long-runs | =anvil-fusion-plan= merges implementation plans with repo-reality checks (files/APIs named by a plan must exist); long-run quests can execute distiller-flagged hard steps as panels (=:step-panel=) with a claim-verification gate between steps (=:verify-steps=). |
  73. | Trajectory library | =anvil-fusion-traj= stores verified wins (admission gate: ≥1 confirmed claim, zero refuted) and prepends retrieved exemplars to future panel prompts — self-improvement without weight updates. |
  74. | Token thrift (measured) | Per-tool volume telemetry (=metrics-token-report=), distilled test runs (=ert-run-distilled=, ~120-char results), diff-first re-reads (=file-read-delta=, ~126x smaller re-reads), search snippet clamps (~87% smaller), verdict cache + sequential skeptics, judge-input dedup, and an opt-in response budget with continuation fetch (=disclosure-fetch=). |
  75. These benchmark figures describe specific fixtures, not a general completion
  76. gain. Later coding fixtures were saturated; coding completion uplift remains
  77. unproven. A six-question KB benchmark improved the strong tier from 0.50 to
  78. 0.60, while the weak tier declined from 0.40 to 0.37.
  79. v1.3.0 highlights (previous wave):
  80. | Area | What changed |
  81. |------+--------------|
  82. | Codebase graph | =anvil-defs= now indexes call edges for Elisp, Python, JavaScript, and TypeScript, traces caller/callee paths, detects blast radius from changed lines, and ranks architecture clusters. |
  83. | Semantic retrieval | =anvil-semantic= now lands on develop/master as a local-first FTS5 search module with optional vector embeddings through ollama-local by default, plus opt-in Gemini/OpenAI providers. |
  84. | Context compression | New =anvil-context= adds =context-compress= / =context-retrieve= / =context-stats= for JSON, diffs, logs, code excerpts, and prose. Raw text is stored by ccr-id so agents can recover exact context when needed. |
  85. | Mail workflows | =anvil-mu4e= and =anvil-wl= expose structured read/search/compose/send surfaces over local mail stores. The WL path is Maildir-first and CJK-friendly; sends are gated. |
  86. | CAD workflows | =anvil-cad= reads and edits ASCII DXF/SVG through a shared entity IR, with outline, extract, annotate, batch-update, and generate tools. |
  87. | Long-running evaluation | The fusion modules add panel, async, long-run store, and MCP surfaces for comparing agent outputs and keeping only compact summaries in the parent context. |
  88. | Client setup | README now documents both Claude Code and Codex CLI MCP registration, plus AGENTS.md / CLAUDE.md guidance for compression tools. |
  89. * Why does this save tokens?
  90. LLM agents pay per token. A naive =Read file → Edit file= loop
  91. ships the whole file twice across the wire. Anvil's primitives
  92. operate on regions, headings, buffer state — only diffs cross.
  93. | Scenario | Reduction | What's happening |
  94. |---------------------------------------------------------+-----------+----------------------------------------|
  95. | Inserting/deleting one line in a large file | *~90%+* | No full-file Read+Write |
  96. | 3+ edits to the same file | *~70%* | One round trip + atomic write |
  97. | Adding N key/value pairs to a JSON / config dictionary | *~73%* | i18n, feature flags, etc. |
  98. | Bulk-adding translations to TS/JS ={ ja: "..." }= data | *~78%* | Mapping JSON sent once |
  99. | Extracting repeating structured records from huge files | *~50%* | Legacy migration, ETL |
  100. | Bulk docstring change across N files | *~60-80%* | All files in a single call |
  101. Numbers are measured; case studies in [[https://github.com/zawatton/anvil.el#efficiency--why-anvil-saves-ai-tokens][the Efficiency section]].
  102. A typical refactoring session saves *15,000-25,000 tokens*.
  103. * Architecture
  104. #+begin_example
  105. ┌──────────────────────────┐
  106. │ Claude Code / Codex CLI │
  107. │ (any MCP-speaking AI) │
  108. └────────────┬─────────────┘
  109. │ MCP / stdio JSON-RPC
  110. ┌────────────▼─────────────┐
  111. │ anvil.el │ ← Emacs primitives
  112. │ ┌──────┬──────┬──────┐ │ exposed as MCP tools
  113. │ │ file │ org │ elisp│ │
  114. │ └──────┴──────┴──────┘ │
  115. └────┬─────────────────┬───┘
  116. │ │
  117. ┌────────▼─────────┐ ┌─────▼──────────────┐
  118. │ Running Emacs │ │ NeLisp v1.2.0 │
  119. │ daemon │ │ standalone reader │
  120. │ (full feature set)│ │ (selected modules) │
  121. └──────────────────┘ └────────────────────┘
  122. #+end_example
  123. The AI client speaks MCP to anvil.el. anvil.el dispatches to a
  124. running Emacs daemon (default — full feature set) or to the NeLisp
  125. standalone reader through =bin/anvil-runtime= (selected modules, no
  126. Emacs install needed).
  127. * Components
  128. The anvil project is split across four repos so each part stays
  129. small and has its own release cadence:
  130. | Repo | Role | Required? |
  131. |------+------+-----------|
  132. | [[https://github.com/zawatton/anvil.el][anvil.el]] | The AI brain — MCP server, ~40 tools by default (each optional module adds its own) | yes |
  133. | [[https://github.com/zawatton/anvil-ide.el][anvil-ide.el]] | Human IDE layer — treesit nav, dashboard, info-look | optional, Emacs users |
  134. | [[https://github.com/zawatton/anvil-pkg][anvil-pkg]] | Nix-backed pkg manager — lets the AI install its own dependencies | optional |
  135. | [[https://github.com/zawatton/nelisp][NeLisp]] | Standalone reader — runs Elisp without Emacs | optional, =bin/anvil-runtime= path |
  136. * Installation
  137. Pick a path based on what you want.
  138. ** Path A — no Emacs install required (NeLisp standalone runtime)
  139. For users who want the MCP tool surface without an Emacs daemon —
  140. CI runners, ephemeral containers, or "I don't use Emacs but want to
  141. cut Claude Code / Codex CLI token use."
  142. Build the NeLisp v1.2.0 standalone reader and use the matching
  143. =nelisp-emacs-lib= checkout as described in the [[https://github.com/zawatton/nelisp][NeLisp setup guide]].
  144. To expose SQLite-backed tools, build the dynamic reader with
  145. =NELISP_READER_DYNAMIC=1 make standalone-reader=. From an =anvil.el=
  146. checkout, inspect the resolved runtime with =bin/anvil-runtime doctor=,
  147. prepare its schema and tool caches with =bin/anvil-runtime prewarm=, then
  148. serve MCP with =bin/anvil-runtime mcp serve=. The exact tools depend on
  149. the selected modules; SQLite-backed memory and worklog tools require the
  150. dynamic reader and their modules to be enabled. Use matching NeLisp and
  151. =nelisp-emacs-lib= revisions. Linux DB-backed use was exercised under
  152. WSL and Windows stdio was exercised; Windows TCP and macOS standalone
  153. operation are unverified. Isolated Linux SQLite queries were verified with
  154. both framing modes, including ordered row truncation. Backends without a
  155. working native cursor use a compatibility cursor that materializes the
  156. query result; the response row cap does not bound database reads or memory
  157. use. Working native cursors retain their streaming behavior.
  158. For example, enable the database-backed set before prewarming and
  159. serving:
  160. #+begin_src bash
  161. export ANVIL_TOOL_MODULES=anvil-discovery,anvil-sqlite,anvil-bench,anvil-state,anvil-memory,anvil-worklog
  162. bin/anvil-runtime prewarm
  163. bin/anvil-runtime mcp serve
  164. #+end_src
  165. ** Path B — Emacs integrated (recommended for Emacs users)
  166. For day-to-day Emacs users. Pin to v1.4.1 via your favourite
  167. package manager.
  168. *** Quick install (one command)
  169. #+begin_src bash
  170. # Linux / macOS
  171. curl -fsSL https://raw.githubusercontent.com/zawatton/anvil.el/master/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 211 on GitHub
  172. #+end_src
  173. #+begin_src powershell
  174. # Windows
  175. iwr -useb https://raw.githubusercontent.com/zawatton/anvil.el/master/install.ps1 | iex
  176. #+end_src
  177. The installer auto-installs Emacs (=apt= / =dnf= / =brew= /
  178. =winget=), clones the repo, starts the daemon, drops the MCP bridge
  179. into =~/.emacs.d/=, and registers the server in =~/.claude.json=.
  180. Add =--skip-emacs= (or =-SkipEmacs= on Windows) if Emacs is already
  181. installed.
  182. *** Manual via Emacs package manager
  183. #+begin_src emacs-lisp
  184. ;; async-installer
  185. (async-installer-git-add "https://github.com/zawatton/anvil.el.git"
  186. :tag "v1.4.1"
  187. :main "anvil.el")
  188. ;; or straight.el
  189. (straight-use-package
  190. '(anvil :type git :host github :repo "zawatton/anvil.el"
  191. :branch "v1.4.1"))
  192. ;; or elpaca
  193. (elpaca (anvil :host github :repo "zawatton/anvil.el"
  194. :ref "v1.4.1"))
  195. #+end_src
  196. After installing:
  197. #+begin_src emacs-lisp
  198. (require 'anvil)
  199. (anvil-enable)
  200. (anvil-server-start)
  201. #+end_src
  202. ** Path C — anvil-pkg for Nix-backed AI tooling (optional)
  203. Lets the AI install its own system dependencies (=ripgrep=, =fd=,
  204. language servers, anything in nixpkgs) via one Lisp form. Requires
  205. Nix on the host.
  206. #+begin_src emacs-lisp
  207. (async-installer-git-add "https://github.com/zawatton/anvil-pkg.git"
  208. :main "anvil-pkg.el")
  209. (require 'anvil-pkg)
  210. (require 'anvil-pkg-dsl) ; for `pkg-define' macro
  211. (anvil-pkg-enable) ; registers pkg-* MCP tools
  212. #+end_src
  213. Now the agent can call =(pkg-install "ripgrep")= or define custom
  214. builds with =(pkg-define ...)=. Repo: [[https://github.com/zawatton/anvil-pkg][zawatton/anvil-pkg]].
  215. ** Path D — anvil-ide.el for the Emacs IDE layer (optional)
  216. Adds the human-side IDE features (treesit navigation, the worker
  217. dashboard, =info-lookup-symbol=).
  218. #+begin_src emacs-lisp
  219. (async-installer-git-add "https://github.com/zawatton/anvil-ide.el.git"
  220. :main "anvil-ide.el")
  221. (require 'anvil-ide)
  222. #+end_src
  223. Repo: [[https://github.com/zawatton/anvil-ide.el][zawatton/anvil-ide.el]].
  224. * Quick Start
  225. After installing via Path B:
  226. 1. Start the daemon — ~M-x anvil-enable~ then ~M-x anvil-server-start~
  227. 2. Print the MCP config snippet — ~M-x anvil-describe-setup~
  228. 3. Paste the snippet into =~/.claude.json= (or your client's MCP
  229. config file)
  230. 4. Restart your AI client; you should see =anvil-*= tools in its
  231. tool-list
  232. Full walkthrough including Claude Code / Claude Desktop config:
  233. [[file:docs/QUICKSTART.org][docs/QUICKSTART.org]].
  234. * Why anvil?
  235. - *LLM-agnostic* — works with any MCP-compatible client
  236. - *Token-efficient* — primitives operate on regions, headings,
  237. buffer state, not whole files
  238. - *Multi-agent coordination* — fan out to five AI CLIs in parallel
  239. with consensus and a meta-LLM judge, all from inside Emacs
  240. - *Safe by design* — long-running tasks run in a worker Emacs under
  241. a shared deadline; timed-out processes are cleaned up
  242. - *Org-mode native* — first-class org read / write / refactor
  243. - *Large file safe* — handles 1.2 MB+ files without truncation
  244. - *Cross-platform* — Linux, macOS, Windows, WSL
  245. - *Modular* — load only what you need, extend with your own modules
  246. * For non-Emacs users — what setup costs you
  247. Anvil runs in the background as an MCP server. Your day-to-day
  248. editor (VSCode / Cursor / Neovim / Claude Code / Codex CLI itself) does not
  249. change.
  250. #+begin_example
  251. AI client ──MCP──▶ Anvil (Emacs daemon, headless) ──▶ file ops
  252. (VSCode / Cursor / (only diffs cross)
  253. Claude Code / Codex CLI, …)
  254. #+end_example
  255. You don't have to open an Emacs window or write =init.el=.
  256. *Honest costs:*
  257. - *15-30 minutes of first-time setup* on Path B (install Emacs,
  258. clone anvil, wire up MCP) — or zero on Path A (no Emacs at all)
  259. - *Resident memory* — Path B keeps an Emacs daemon running;
  260. Path A's footprint depends on the selected NeLisp modules
  261. - *One more dependency to maintain* — Emacs updates and OS
  262. migrations include it (Path B only)
  263. For 30+ minute agent sessions a few times a month, the one-time
  264. setup pays itself back almost immediately via the token savings
  265. above.
  266. * Feature Highlights
  267. Anvil's default install exposes *~40 MCP tools* (=anvil.el= core modules). Each optional module you enable adds its own tools — anvil-memory ~22, anvil-orchestrator ~23, anvil-http ~9, anvil-defs ~7, anvil-session ~6, etc. Pick what you actually want; you don't have to load everything
  268. (=anvil.el= core + the [[https://github.com/zawatton/anvil-ide.el][anvil-ide.el]] split + the [[https://github.com/zawatton/anvil-pkg][anvil-pkg]]
  269. sister package). Highlights:
  270. | Capability | What it does |
  271. |------------+--------------|
  272. | =bin/anvil-runtime mcp serve= (v1.0+) | *Standalone path — no Emacs install required.* The NeLisp v1.2.0 reader evaluates Elisp and serves selected Anvil tools over MCP. Use =doctor= and =prewarm= to inspect and prepare the runtime; SQLite-backed tools require the dynamic reader and enabled modules. |
  273. | =anvil-pkg= (v1.0) | Elisp-DSL package manager backed by the Nix store. =(pkg-install "ripgrep")= for nixpkgs attributes; =(pkg-define …)= macro for custom builds (=stdenv= / =rust= / =python= / =go= / =emacs-package= build systems). Same idea as Guix in Scheme — but in Elisp, integrated with anvil's MCP surface so an AI agent can install its own dependencies in one Lisp form. Lives in [[https://github.com/zawatton/anvil-pkg][zawatton/anvil-pkg]] |
  274. | =anvil-ide.el= split (v1.0) | Emacs-only IDE layer (treesit nav, =worker-ui= dashboard, =info-lookup-symbol=) moved out to [[https://github.com/zawatton/anvil-ide.el][zawatton/anvil-ide.el]]. Install both for the original feature set; install only =anvil.el= if you want the AI-side workbench without the human IDE surface |
  275. | Treesit subprocess fallback (v1.0) | Doc 38 Phase F + G — =anvil-ts= / =-js= / =-py= structural ops keep working on hosts without an Emacs tree-sitter (e.g. NeLisp standalone) via Python =ast= / acorn subprocess fallback. Token-efficient AST queries preserved on the Rust substrate |
  276. | =anvil-orchestrator= | Fan out one prompt to up to five AI CLIs (=claude= / =aider= / =gemini= / =ollama= / =codex=) in parallel. Jaccard consensus + meta-LLM judge + DAG dependencies + =anvil-cron= integration for nightly PDCA loops |
  277. | =anvil-memory= (v0.4.0 + 2026-05) | Auto-memory engine with Bayesian TTL + FTS5 full-text search. Scans multi-provider =.md= memories, supports DB-primary =memory-add= / =memory-get= / =memory-export-md=, WHISPER session deltas, contradiction scans, static HTML export, and review-only memory harvesting. Designed for one per-machine SQLite DB plus text export, not binary DB merges |
  278. | =anvil-memory-bridge= (2026-05) | Local JSON bridge in front of =anvil-memory= and =anvil-worklog=. Adds read/write memory endpoints, event stream, read-replica pull, worklog search/list/get endpoints, configured-origin CORS, a side-load browser extension for Claude.ai / ChatGPT / Gemini, and a static mobile thin client with offline save queue |
  279. | =anvil-autoresearch= (2026-05) | Safe self-improvement primitives: scan local Web/X/YouTube/design notes for implementation candidates, rank weak MCP docstrings, propose / harvest / apply descriptions behind eval+holdout gates, route provider-mapping experiments through the orchestrator, scaffold NeLisp Phase 47 codegen tasks, and watch progress in a tabulated-list dashboard |
  280. | =anvil-defs= codebase graph (v1.3.0) | SQLite-backed definitions, references, call graph, change detection, trace path, callers/callees ranking, dead-code hints, and architecture clustering across Elisp / Python / JS / TS projects |
  281. | =anvil-semantic= (v1.3.0) | Local-first semantic retrieval over org/text/code. FTS5 + CJK LIKE fallback stay fully local; optional =semantic-embed-index= adds cosine retrieval using ollama-local by default or opt-in Gemini/OpenAI providers |
  282. | =anvil-context= (v1.3.0) | Headroom-inspired reversible context compression. Compress JSON / diff / log / code / prose before handing it back to the model; retrieve raw context later by =ccr-id= when exact wording matters |
  283. | =anvil-mu4e= / =anvil-wl= (v1.3.0) | Structured mail tools for local mu4e and Wanderlust/Maildir workflows. Read/search/compose surfaces are structured; send tools are gated so agent-driven mail cannot transmit silently |
  284. | =anvil-cad= (v1.3.0) | DXF/SVG outline, extract, annotate, batch-update, and generate tools through a format-agnostic entity IR |
  285. | =anvil-fusion= stack (2026-07) | Verified multi-model answers: named panels (=opus-solo= / =claude-pair= / =sovereign=), claim extraction + KB/skeptic/execution verification, a judge barred from adopting refuted claims, cascade routing, plan fusion, panelized long-run steps with inter-step verify gates, and a verified-trajectory exemplar library. Usage: [[file:docs/FUSION-GUIDE.org][docs/FUSION-GUIDE.org]] |
  286. | =anvil-tools-by-intent= + =anvil-manifest= (v0.4.0 + 2026-05) | Intent-based tool discovery plus =ANVIL_PROFILE= filter. The 2026-05 update adds Tool Attention: dynamic query-based ranking, optional embedding backends, state preconditions, schema trimming, warm LRU full-schema retention, recovery suggestions, and a Doc43 bridge for docstring rewrite candidates |
  287. | =anvil-worklog= (2026-05) | SQLite-backed AI worklog index. Old org logs can be scanned, new entries are DB-primary via =worklog-add=, and bridge endpoints expose read-only search/list/get to other AI clients. The DB handle self-recovers after file replacement/unlink events and uses short write transactions for =worklog-add= |
  288. | =anvil-claude-watchdog= (2026-05) | Linux procfs/jsonl watchdog for Claude Code TUI hangs. Detects State=R stalls and the State=S spinner/MCP-child-IO variant, records events, notifies the desktop, and offers confirmation-gated manual recovery via =claude --resume= staged in tmux |
  289. | =anvil-sexp= / =sexp-cst= / =py= / =ts= / =js= (v0.4.0) | Language-aware structural edits. Reader-based Elisp edits, tree-sitter CST for Python / TypeScript / TSX / JavaScript — AST-level refactors without touching whole files |
  290. | =anvil-session= + Claude Code hooks (v0.4.0) | Session snapshot / resume + 5 lifecycle hooks (PreCompact / SessionStart / PostToolUse / UserPromptSubmit / SessionEnd). Captures branch + task summary with 14-day TTL so session restarts don't re-cold |
  291. | =anvil-shell-filter= (v0.4.0) | Shell output compression — 20 bundled filters for git / rg / pytest / ert-batch / docker-logs etc. Raw output stashed with TTL so callers can still recover full text when needed |
  292. | =file-batch= | Apply multiple edits to the same file atomically in one round trip (up to ~90% token reduction) |
  293. | =org-read-outline= / =org-read-headline= | Read just the headings or a single subtree, even on a 13,000-line org. No full-file read needed |
  294. | =anvil-worker= | Dispatch long-running tasks (OCR, PDF conversion, batch file scans) to a separate worker Emacs with a shared deadline budget and timeout cleanup |
  295. | Large org file editing | Edit org files of 1.2 MB or more without truncation (avoids the Windows file-mount issue) |
  296. | LLM client agnostic | Claude Code / Codex CLI / Claude Desktop / GPT / local LLMs via Ollama — all speak through MCP |
  297. | =anvil-modes-allow-buffer-modify= | Configure major modes where Anvil tools modify live buffers directly rather than visiting files, preserving unsaved changes. |
  298. For numerical evidence and detailed case studies, see [[https://github.com/zawatton/anvil.el#efficiency--why-anvil-saves-ai-tokens][Efficiency — why Anvil saves AI tokens]].
  299. For the full module list, see [[https://github.com/zawatton/anvil.el#modules][Modules]].
  300. * Architecture α — NeLisp delegate active
  301. Several anvil modules now delegate their core helpers to NeLisp
  302. when available (=fboundp= guard + fallback for standalone usage).
  303. Modules ported as of 2026-04-25 architecture α:
  304. - =anvil-http= — 25 helpers (~467 LOC) delegate to =nelisp-http=
  305. - =anvil-state= — 5 pure helpers delegate to =nelisp-state=
  306. - =anvil-defs= — SQLite Elisp index delegates to =nelisp-defs-index=
  307. (Doc 25)
  308. - =anvil-org-index= — 2 functions delegate to =nelisp-org-index=
  309. (Doc 26)
  310. Total ≈ 37 helpers / ~573 LOC delegated. Behaviour with NeLisp
  311. absent is unchanged (tests cover both paths).
  312. * Efficiency — why Anvil saves AI tokens
  313. LLM agents pay per token, and every Read/Edit round trip costs
  314. both bytes on the wire and orchestration overhead. Anvil's tools
  315. are designed to keep the agent's context budget free for reasoning,
  316. not bookkeeping.
  317. ** Orchestrator measurements (v0.3.0, 2026-04-19)
  318. First publishable numbers from [[file:benchmarks/][=benchmarks/=]]
  319. — one production daemon on Debian 13, n=1 per cell, scenario S1
  320. (recursive fibonacci via =claude-haiku-4-5= / =codex-gpt-5.4= /
  321. =ollama-llama3.2:3b=). Reproduce with the checked-in harness.
  322. | Condition | Wall | Cost |
  323. |--------------------------------------------------------+--------+--------|
  324. | Solo =claude-haiku= | 14.2 s | $0.030 |
  325. | 3× =claude-haiku= in parallel | 15.1 s | $0.087 |
  326. | 3-way consensus (claude + codex + ollama) | 12.5 s | $0.029 |
  327. | 3-way consensus + meta-LLM judge | 34.6 s | $0.041 |
  328. Three parallel Claude tasks finish in *1.07×* the solo-task
  329. wallclock — the orchestrator's pool dispatches them concurrently
  330. with near-zero overhead. A three-provider fan-out with consensus
  331. is *both faster and cheaper than three Claudes* on the same
  332. prompt: the codex (ChatGPT Plus OAuth) and ollama (local) calls
  333. have no per-token cost, and the pool overlaps the slowest.
  334. Codex on Plus scaled to *eight concurrent* requests with zero 429s
  335. on this account; the concurrency ramp (levels 1 / 3 / 6 / 8 @
  336. 5.5 s / 6.6 s / 9.8 s / 6.8 s wallclock) is in the same CSV.
  337. Full methodology and caveats in
  338. [[file:benchmarks/results/report-2026-04-19.org][benchmarks/results/report-2026-04-19.org]].
  339. ** Manifest profile — session-prompt manifest cost (v0.4.0)
  340. Doc 26 =anvil-manifest= lets each client connect under a virtual
  341. server-id (=emacs-eval-ultra= / =-nav= / =-core= / =-agent= / =-edit=)
  342. that filters the =tools/list= response. Handlers stay live — hidden
  343. tools are still callable via explicit =tools/call= — but the
  344. manifest prelude that Claude Code parses at session start shrinks:
  345. | Profile | Advertised tools | Approx tokens | Use case |
  346. |---------+------------------+---------------+---------------------------------------|
  347. | =full= | 198 | ~20,400 | All capabilities |
  348. | =core= | 54 | ~5,800 | Daily coding, no memory engine |
  349. | =lean= | 59 | ~6,620 | Memory engine off |
  350. | =nav= | 28 | ~3,100 | Read-only exploration |
  351. | =ultra= | 17 | ~2,740 | Hot tools + =ts_extended= lazy-load |
  352. | =agent= (v0.4.0) | ≈60 (intent-filtered) | ~6,500 | Orchestrator / session / memory / edit |
  353. | =edit= (v0.4.0) | ≈40 (intent-filtered) | ~4,200 | Pure file / org / code / json editor |
  354. | =dynamic= (2026-05) | Top-K + warm LRU | query-dependent | Tool Attention + schema trimming |
  355. Measure your own profile cost at any time via the =manifest-cost=
  356. MCP tool (returns ={:profile :advertised-count :registered-count
  357. :approx-tokens}=).
  358. The 2026-05 update extends this into a Tool Attention layer. Set
  359. =ANVIL_PROFILE=dynamic= and optionally =ANVIL_ATTENTION_QUERY= to
  360. rank tools by the current intent; tools whose =:preconditions= do
  361. not match =ANVIL_STATE_TAGS= are filtered out. When schema trimming
  362. is enabled, only the Top-K focused tools, manifest self-tools, and
  363. recent warm-LRU tools keep full schemas; the rest advertise compact
  364. name/type-only schemas. =manifest-recovery-suggest= explains why a
  365. tool is hidden or unfocused, and =manifest-docstring-candidates=
  366. hands weak descriptions to Doc43 autoresearch.
  367. *Orchestrator child sessions* (Doc 26 Phase 1b, extended in Doc 34
  368. Phase B) auto-inject =--mcp-config= pointing at =emacs-eval-PROFILE=
  369. when =anvil-orchestrator-manifest-profile= is set. Typical benefit:
  370. a 20-provider consensus run with 200 total child sessions on
  371. =full= spends ~4 M tokens just advertising tools; the same run
  372. on =ultra= spends ~550 k — *~87% reduction on manifest alone*,
  373. before the agent says a word.
  374. ** Operate on regions, not whole files
  375. Generic file tools force a Read-then-Edit pattern that ships the
  376. whole file each time. Anvil exposes targeted operations that send
  377. only the delta:
  378. | Task | Generic flow | Anvil flow |
  379. |------+--------------+------------|
  380. | Replace one string in a 1.2 MB org file | Read 1.2 MB → Edit (sends old + new) | =anvil-file-replace-string= (pattern + replacement only) |
  381. | Read one heading from a 30k-line =init.org= | Read & paginate | =anvil-org-read-headline= (subtree only) |
  382. | Insert near the end of a large file | Read whole file → rewrite | =anvil-file-insert-at-line= (delta only) |
  383. For org-mode refactors specifically, MCP-backed operations
  384. (section move, refile, split) run *10–20× cheaper in tokens* than
  385. their Read + Write equivalents.
  386. In v1.4.1, =file-read= defaults to a 1 MiB raw-byte cap.
  387. For larger files, pass =offset="0"= and =limit="200"=; reduce the limit
  388. if the selected page also exceeds the cap. Pagination uses bounded chunks
  389. and retains only the selected page. Preserving automatic line-ending
  390. detection may require an additional bounded scan; exact =:total-lines=
  391. still needs a complete scan. The cap does not bound encoded MCP response size or scan
  392. time. Set =anvil-file-max-inline-read-bytes= to nil, zero or a negative
  393. integer only when explicitly choosing legacy full-file reads.
  394. Successful inline tool-result text also defaults to a 2 MiB limit after
  395. projecting UTF-8 JSON string escaping, excluding surrounding quotes. The
  396. server checks normalized results before and after disclosure processing;
  397. oversized content is replaced with a fixed error before payload telemetry.
  398. Use paginated, filtered, tee or asynchronous interfaces for larger results.
  399. Set =anvil-server-max-inline-result-bytes= to nil or a non-positive integer
  400. to explicitly restore legacy behavior. The cap applies to successful text;
  401. its fixed rejection diagnostic has a separate bound, and existing error
  402. paths and complete response frames are outside it. Tool execution and rich
  403. result normalization can still allocate large values before this check.
  404. Automatic harness failure telemetry also bounds error data before rendering.
  405. It limits visited elements, nesting and characters. Oversized data is truncated
  406. or replaced; cyclic or opaque values use omission markers. Stored error
  407. messages default to 4,096 characters and raw context to 500; configure
  408. =anvil-harness-telemetry-error-message-max-chars= and
  409. =anvil-harness-telemetry-raw-context-max-chars= for smaller fields. Zero keeps
  410. the field empty, invalid settings use finite defaults, and larger settings
  411. are clamped to 4,096 characters. Classification uses bounded message text and
  412. retains the existing rule order. This applies to automatic error recording;
  413. direct manual recording, other server error paths and cancellation remain
  414. separate.
  415. Raw errors caught by =anvil-server-with-error-handling= are also copied before
  416. printing: at most 512 visited values, depth 8 and 4,096 leaf characters.
  417. Large strings are truncated; cyclic or opaque values use omission markers.
  418. The pure snapshot implementation is shared with telemetry. The existing
  419. =anvil-server-tool-error-max-chars= setting controls final text truncation;
  420. setting it to nil disables that final cap while the independent data-copy
  421. limits remain finite. Small ordinary =Error: ...= messages retain their text.
  422. Generic server error formatting, explicit tool-throw text, lazy loaders,
  423. quit/invalid-parameter/not-found responses and transport containment remain
  424. separate.
  425. ** Batch edits into one round trip
  426. When an agent makes several edits to the same file, each becomes a
  427. separate tool call with its own request/schema/response overhead.
  428. =anvil-file-batch= applies a vector of edits in a single
  429. transaction — *up to ~90% token reduction* versus issuing the
  430. edits one at a time.
  431. ** Web fetch caching (anvil-http + anvil-browser)
  432. =anvil-http-get= and =anvil-browser= ship with an in-process
  433. TTL cache keyed on URL + auth preset. Measurement
  434. ([[file:benchmarks/results/http-browser-report-2026-04-19.org][=http-browser-report-2026-04-19.org=]]):
  435. within the default TTL, *second and subsequent fetches cost 0–2 ms
  436. wallclock and send zero bytes over the network* — the response
  437. plist's =:from-cache= is =t=. An agent that fetches the same
  438. docs page / GitHub PR / Wikipedia article twice during a session
  439. pays for it exactly once.
  440. =anvil-browser= returns an accessibility-tree snapshot instead
  441. of raw HTML, which shrinks the payload for rendered pages.
  442. Measured on four URLs:
  443. | URL | http bytes | browser bytes | reduction |
  444. |---------------------------------+-----------:+--------------:+----------:|
  445. | =en.wikipedia.org/wiki/Emacs= | 276 082 | 25 122 | 11.0× |
  446. | =news.ycombinator.com/= | 35 098 | 13 597 | 2.6× |
  447. | =example.com/= | 528 | 73 | 7.2× |
  448. Raw-text endpoints (e.g. =raw.githubusercontent.com/…/README=)
  449. degenerate to a placeholder snapshot; use =anvil-http-get= for
  450. those, not browser. Smaller payload means smaller prompt when
  451. the agent quotes the fetch back to the LLM.
  452. ** Heavy work runs out of band
  453. Slow operations (large tangles, full-tree org scans, byte-compile)
  454. are dispatched to a worker daemon pool so the agent's main
  455. connection stays responsive.
  456. Measured impact: =org-babel-tangle= on a ~1 MB =init.org= runs
  457. ~30 s in-process but ~2 s when worker-dispatched — *~15× faster
  458. end-to-end*, and the agent's main session is never blocked.
  459. ** Scales to large org databases
  460. Naïve approaches that walk a temp buffer time out on org files
  461. past ~50 KB inside an MCP request. Anvil's org tools use streaming
  462. regex scanners, so heading lookups and outline reads stay fast on
  463. multi-megabyte org trees (the kind of monolithic =init.org= or
  464. journal file power users actually maintain).
  465. ** Standalone runtime — selected tools without an Emacs daemon (v1.4.0)
  466. =bin/anvil-runtime mcp serve= uses the NeLisp reader without starting an
  467. Emacs daemon. Its tool surface depends on enabled modules and the matching
  468. NeLisp / =nelisp-emacs-lib= revisions. SQLite-backed modules require the
  469. dynamic reader. Run =doctor= and =prewarm= as described in Path A above,
  470. then inspect =tools/list= for the available tools. Full Emacs and IDE
  471. coverage is not implied by standalone support.
  472. Existing Emacs users can continue using =bin/anvil mcp serve=.
  473. ** Case study: TypeScript refactoring at scale
  474. Anvil isn't just theory, and it isn't org-mode-only. It was
  475. validated on a real large-scale TypeScript migration project —
  476. the [[https://github.com/zawatton/newDTW.github.io][newDTW]] repository, which ports a decompiled HSP application
  477. to TypeScript:
  478. - *16,000+* lines of TypeScript across *1,400+* modules
  479. - Massive type-definition files (thousands of lines) tightly
  480. coupled with implementation files
  481. - High frequency of multi-point edits within the same file
  482. The same Anvil tools that help with org-mode delivered
  483. measurable wins here too.
  484. *** =anvil-file-batch= — multiple edits to one file
  485. TypeScript refactoring routinely means several simultaneous
  486. edits to one file: adding imports, modifying type defs,
  487. replacing implementation, renaming methods.
  488. Measured: 6 edits to a 130-line source file.
  489. | Method | Tokens | Round trips |
  490. |-----------------------+----------+-------------|
  491. | Generic =Edit= ×6 | ~4,800 | 6 |
  492. | =anvil-file-batch= | ~1,500 | 1 |
  493. | Reduction | *~70%* | *83%* |
  494. *** =anvil-file-replace-regexp= — bulk type/identifier renames
  495. Tasks like changing =Promise<T>= → =AsyncResult<T>= across the
  496. codebase, or renaming a globally-used variable, finish in *one
  497. command*. The conventional flow (grep across hundreds of files,
  498. read each, edit individually) is many round trips of the same
  499. mechanical work.
  500. *** =anvil-file-insert-at-line= / =-delete-lines= — localized ops on large files
  501. Use case: adding a single field to a 4,000+ line type-definition
  502. file, or to a global state interface.
  503. | Method | Tokens |
  504. |------------------------------+------------|
  505. | Read full file + Edit | thousands |
  506. | =anvil-file-insert-at-line= | tens |
  507. | Reduction | *~90%+* |
  508. *** =anvil-json-object-add= — i18n & config dictionaries
  509. For workflows that append many key/value pairs to a JSON object
  510. (language dictionaries, feature flags, configuration maps), the
  511. generic =Edit= tool requires a long anchor string in every
  512. round trip.
  513. Measured: adding ~200 i18n keys in batches of 40.
  514. | Method | Tokens | Calls |
  515. |------------------------------+----------+-------|
  516. | Generic =Edit= ×5 | ~30,000 | 5 |
  517. | =anvil-json-object-add= ×5 | ~8,000 | 5 |
  518. | Reduction | *~73%* | 0 |
  519. Handles trailing commas, closing-brace placement, indent
  520. detection, and duplicate-key policy automatically.
  521. *** =anvil-file-ensure-import= — idempotent import insertion
  522. Adding =import= lines across many source files is one of the
  523. most repetitive edit patterns. =file-ensure-import= checks
  524. whether the line is already present and inserts after the last
  525. matching header line only if needed. Works with any
  526. =:after-regex= so it applies equally to Emacs =(require ...)=
  527. blocks.
  528. *** =anvil-file-batch-across= — coordinated multi-file edits
  529. For a refactor that touches N files in similar ways (docstring
  530. updates, renames, import additions), pair this with
  531. =file-batch='s per-file op lists to complete the whole
  532. refactor in one MCP call.
  533. *** =anvil-code-extract-pattern= — structured data extraction from huge files (read-only)
  534. For legacy data extraction and ETL, the usual flow is "read the
  535. whole file then assemble with regex." This tool replaces that
  536. with a single MCP call. =:block-start= matches each block header,
  537. =:block-end= picks the closing strategy (=brace-balance= skips
  538. braces inside strings), =:fields= regexps capture per-field
  539. values; the result comes back as a list of plain-data records.
  540. For =brace-balance=, =:block-start= should stop before the opening
  541. ={=; the matcher then finds that brace and balances from there.
  542. The file body itself is never sent back to the agent.
  543. Measured: extracted 347 item definitions from =func492.ts= in
  544. newDTW (3,407 lines of legacy if-blocks).
  545. | Method | Tokens |
  546. |-------------------------------------+----------------|
  547. | Whole-file Read + extractor script | ~8,000 + α |
  548. | =anvil-code-extract-pattern= ×1 | ~3,000-5,000 |
  549. | Reduction | *~50%* |
  550. Useful anywhere repeating structured text appears: legacy
  551. migrations, data migrations, i18n inventories.
  552. *** =anvil-code-add-field-by-map= — bulk field add to TS/JS object literals
  553. For i18n-style work — "add =add-key: \"...\"= to every
  554. ={lookup-key: \"...\"}= in the same file" — this collapses the
  555. whole loop into a single call that takes only a mapping JSON.
  556. Default is dry-run (=:apply= defaults to nil), so the typical
  557. flow is: preview first, then re-call with =:apply t= to write —
  558. two-step safety with no extra plumbing.
  559. Measured: 8 data files in newDTW (25-100 entries each), adding
  560. =en= translations.
  561. | Method | Tokens |
  562. |---------------------------------------------------+----------|
  563. | Per-file Read + full-rewrite Write | ~16,000 |
  564. | =anvil-code-add-field-by-map= (mapping only) | ~3,200 |
  565. | Reduction | *~78%* |
  566. Existing add-key handling is governed by =:on-existing= (default
  567. =error= for fail-loud), preventing silent overwrites.
  568. *** Why TypeScript benefits especially
  569. | TypeScript characteristic | Why Anvil helps |
  570. |-------------------------------------------------+--------------------------------------------------|
  571. | Type defs + implementations coexist in one file | Many edits per file → =file-batch= shines |
  572. | Massive type-definition files | Localized ops avoid full-file reads |
  573. | Frequent import additions | =file-insert-at-line= handles routine insertion |
  574. | Global state interfaces | Field additions follow patterns, easy to script |
  575. | Legacy if-block / switch extraction | =code-extract-pattern= removes the full-file read |
  576. | Bulk i18n translations on object literals | =code-add-field-by-map= folds it into one mapping |
  577. Per refactoring session in newDTW, the cumulative saving was
  578. *15,000 to 25,000 tokens* (after =code-extract-pattern= and
  579. =code-add-field-by-map= landed) — context the agent then
  580. spent on actual reasoning instead of file-shuttling.
  581. ** When to reach for Anvil
  582. | Scenario | Anvil benefit |
  583. |-----------------------------------------------+-------------------------------------|
  584. | 3+ edits within the same file | ◎ Major token reduction |
  585. | Localized additions to large files | ◎ Avoids full-file Read |
  586. | Bulk renames (types, identifiers) | ◎ Completes in one command |
  587. | Adding imports / type fields | ○ Fewer round trips |
  588. | Heavy Emacs ops during agent work | ◎ Worker dispatch (~15× faster) |
  589. | Creating new files from scratch | △ Generic =Write= is fine |
  590. | File or repository exploration | × Glob / Grep are better fits |
  591. ** What this looks like in practice
  592. A typical agent session that touches a large config file, refactors
  593. a few org headings, and runs a tangle would otherwise be dominated
  594. by file-shuttling overhead. With Anvil:
  595. - Each edit ships only the *changed bytes*, not the file.
  596. - Multi-step refactors collapse into *one* batched call.
  597. - Slow Emacs ops execute in a *worker*, not the agent's thread.
  598. The result is more useful work per token — the agent's context
  599. budget goes to reasoning about your code, not re-reading it.
  600. * Modules
  601. | Module | Tools | External Deps |
  602. |--------------+------------------------------------------------+------------------|
  603. | =worker= | Isolated sub-Emacs daemon pool for AI calls | — |
  604. | =eval= | Sync/async Elisp evaluation | — |
  605. | =org= | Read/write org headings, outlines, TODO states | org-mode |
  606. | =file= | Safe file ops, batch edits, replace/regexp | — |
  607. | =host= | CPU, RAM, disk, GPU, network, OS info | — |
  608. | =git= | Status, log, diff-stats with CJK path safety | git |
  609. | =proc= | Process listing and inspection | — |
  610. | =net= | Port and network inspection | — |
  611. | =fs= | Directory trees, disk usage, recent files | — |
  612. | =emacs= | Buffer state and disk sync diagnosis | — |
  613. | =text= | URL extraction, link parsing | — |
  614. | =clipboard= | OS clipboard read/write | — |
  615. | =data= | JSON/CSV read/write with UTF-8 enforcement | — |
  616. | =xlsx= | Excel read/write (optional) | Python, openpyxl |
  617. | =pdf= | PDF text extraction (optional) | Python, pymupdf |
  618. | =ide= (split) | Moved to [[https://github.com/zawatton/anvil-ide.el][zawatton/anvil-ide.el]] in 2026-04 (Doc 38). =anvil.el= is now NeLisp-runnable; =anvil-ide.el= bundles the Emacs-only IDE layer (xref / diagnostics / imenu / tree-sitter / info-look / worker-ui dashboard). Install both for the original feature set | anvil-ide.el repo |
  619. | =cron= | Scheduled task runner with worker dispatch | — |
  620. | =elisp= | Agentic Elisp development tools (optional) | — |
  621. | =browser= | Web fetch / interact / capture / screenshot via agent-browser (opt.) | agent-browser CLI |
  622. | =state= | Persistent SQLite-backed KV store (ns / TTL, opt.) | Emacs 29+ |
  623. | =http= | GET/HEAD with ETag/TTL cache via `url-retrieve' (opt.) | Emacs 29+ (state) |
  624. | =orchestrator= | Parallel AI CLI dispatcher (claude / aider / gemini / ollama / codex) with DAG, consensus, meta-LLM judge, live streaming, cron + worktree isolation (opt.) | AI CLIs, Emacs 29+ |
  625. | =orchestrator-routing= | Per-provider latency routing for =orchestrator-routing-select= (v0.4.0) | orchestrator |
  626. | =orchestrator-presets= | Named consensus provider combinations (v0.4.0) | orchestrator |
  627. | =pty-broker= | Node-pty TCP broker for spawning processes that need a real TTY (opt.) | Node.js, node-pty |
  628. | =memory= (v0.4.0 + 2026-05) | Auto-memory index + TTL audit + access tracker, DB-primary add/get/export, WHISPER session deltas, contradiction scans, static HTML export, and review-only harvest candidates (opt.) | Emacs 29+ |
  629. | =memory-bridge= (2026-05) | Local HTTP/JSON API for memory + worklog, write auth, event stream, read-replica pull, CORS, browser extension, mobile thin client (opt.) | =memory=, =worklog= |
  630. | =worklog= (2026-05) | AI worklog org scan + DB-primary =worklog-add= + search/list/get/export tools; stale SQLite handle recovery for long-lived daemons (opt.) | Emacs 29+ |
  631. | =autoresearch= (2026-05) | Candidate scan, MCP docstring proposal/apply/harvest gates, routing experiments, NeLisp codegen task scaffold, tabulated-list dashboard (opt.) | =orchestrator=, optional =memory= |
  632. | =claude-watchdog= (2026-05) | Linux Claude Code hang detector + desktop notification + confirmation-gated tmux resume staging (opt.) | Linux procfs, tmux for recovery |
  633. | =mu4e= (v1.3.0) | Structured tools over local mu4e state: search/read/compose/send helpers with CJK-aware fallbacks and gated sending (opt.) | mu4e, local mail setup |
  634. | =wl= (v1.3.0) | Wanderlust/Maildir tools: local Maildir read/search/compose/draft/send, RFC2047/CJK decoding, gated SMTP send path (opt.) | FLIM/Wanderlust-style mail stack |
  635. | =cad= (v1.3.0) | ASCII DXF/SVG read/edit/generate through a shared entity IR (opt.) | — |
  636. | =fusion= / =fusion-longrun= (v1.3.0) | Agent-output comparison, panels, async collection, long-run result store, MCP review surfaces (opt.) | =orchestrator= |
  637. | =fusion-verify= / =-route= / =-exec= / =-plan= / =-traj= (2026-07) | Verifier-grounded judge (claims + KB/skeptic/mechanical checks + verdict cache), cascade router, worktree execution gating for code candidates, plan fusion with repo-reality checks, verified-trajectory exemplar store (opt.) | =fusion=, =orchestrator=; =state= optional |
  638. | =semantic= (v1.3.0) | Local corpus search over org/text/code using SQLite FTS5, CJK LIKE fallback, hybrid RRF scoring, and optional vector embeddings via ollama/Gemini/OpenAI (opt.) | Emacs 29+, =sqlite=, optional =http= |
  639. | =session= (v0.4.0) | Session snapshot / resume + 5 Claude Code lifecycle hooks (opt.) | =state= |
  640. | =discovery= (v0.4.0) | Intent-based MCP tool discovery (=anvil-tools-by-intent=) + per-tool usage counter (opt.) | =state= |
  641. | =manifest= (v0.4.0 + 2026-05) | Per-session =tools/list= filter driven by =ANVIL_PROFILE=; dynamic Tool Attention adds query ranking, state filtering, schema trimming, warm LRU, and recovery hints (opt.) | — |
  642. | =disclosure= (v0.4.0) | 3-layer read contract + citation URI scheme + =disclosure-help= (opt.) | =org-index= |
  643. | =shell-filter= (v0.4.0) | Shell output compression with 20 bundled filters + tee + gain stats (opt.) | =state= |
  644. | =context= (2026-06) | Headroom-inspired reversible context compression for JSON / diff / log / code / prose, with CCR-style raw retrieval and savings stats (opt.) | =state= |
  645. | =data= (v0.4.0) | JSON path-based edits with preview-by-default: data-get-path / data-set-path / data-delete-path / data-list-keys (opt.) | — |
  646. | =sexp= (v0.4.0) | Reader-based Elisp structural edits: rename-symbol / replace-defun / wrap-form / macroexpand (opt.) | — |
  647. | =sexp-cst= (v0.4.0) | Tree-sitter-elisp CST + runtime =inspect-object= + =sexp-cst-read= / =-edit= / =-repair= (opt.) | Emacs 29+, tree-sitter-elisp grammar |
  648. | =defs= (v0.4.0) | SQLite-backed Elisp symbol index: defs-search / defs-references / defs-signature / defs-who-requires (opt.) | Emacs 29+ |
  649. | =treesit= (v0.4.0) | Tree-sitter shared core for per-language structural modules (opt.) | Emacs 29+ |
  650. | =py= (v0.4.0) | Python structural locators + edits via treesit: py-list-* / py-find-definition / py-add-import etc. (opt.) | =treesit=, tree-sitter-python grammar |
  651. | =ts= (v0.4.0) | TypeScript / TSX structural locators via treesit (opt.) | =treesit=, tree-sitter-typescript grammar |
  652. | =js= (v0.4.0) | JavaScript / JSX structural locators via treesit (opt.) | =treesit=, tree-sitter-javascript grammar |
  653. | =bench= (v0.4.0) | bench-compare / bench-profile-expr / bench-last (opt.) | — |
  654. | =bisect= (v0.4.0) | Test-driven git bisect via worktree-isolated =emacs --batch= (opt.) | =worker= |
  655. | =git-msg= (v0.4.0) | git-commit-message (from staged diff) + git-pr-body (from branch log) (opt.) | =git= |
  656. | =lint= (v0.4.0) | Repo hygiene scanner with pluggable registry: conflict-markers / orphan-ids / broken-scheduled (opt.) | — |
  657. | =uri= (v0.4.0) | URI-based =anvil-uri-fetch= cross-layer resolver (opt.) | =disclosure= |
  658. * Configuration
  659. #+begin_src emacs-lisp
  660. ;; Choose which modules to load (defaults shown)
  661. (setq anvil-modules '(worker eval org file host git proc fs emacs text clipboard data net))
  662. ;; Enable optional modules
  663. (setq anvil-optional-modules '(xlsx pdf ide cron browser))
  664. ;; Token-saving output/context tools used by Claude Code and Codex CLI.
  665. ;; `shell-filter' compresses command stdout; `context' compresses
  666. ;; arbitrary JSON/diff/log/code/text and lets agents retrieve the raw
  667. ;; original by ccr-id when needed.
  668. (add-to-list 'anvil-optional-modules 'state)
  669. (add-to-list 'anvil-optional-modules 'shell-filter)
  670. (add-to-list 'anvil-optional-modules 'context)
  671. ;; Start anvil
  672. (anvil-enable)
  673. (anvil-server-start)
  674. #+end_src
  675. ** Buffer-first editing — anvil-modes-allow-buffer-modify
  676. By default, anvil's org-modifying tools (update-todo-state, add-todo,
  677. rename-headline, edit-body) use a *disk-first* policy: they read
  678. the file into a temporary buffer, apply the edit, write the result
  679. to disk, and refresh any visiting buffers. If any buffer has unsaved
  680. modifications, the operation is refused — anvil will not clobber
  681. your in-progress edits.
  682. When =anvil-modes-allow-buffer-modify= is set to a list of major
  683. modes, anvil switches to a *buffer-first* policy for files whose
  684. open buffers match one of those modes:
  685. 1. Locate the first buffer visiting the file (following indirect
  686. buffers to their base buffer).
  687. 2. Note whether the buffer already has unsaved modifications.
  688. 3. Make the edit directly in the live buffer.
  689. 4. Only save the buffer if it did *not* have unsaved modifications
  690. before the edit — preserving any in-progress user work.
  691. This means an AI agent and a human can collaborate on the same
  692. file without the agent forcing a save that would commit half-finished
  693. edits.
  694. #+begin_src emacs-lisp
  695. ;; Enable buffer-first editing for org files only
  696. (setq anvil-modes-allow-buffer-modify '(org-mode))
  697. ;; Or enable it for every open buffer (fundamental-mode is a
  698. ;; special case that matches any major mode)
  699. (setq anvil-modes-allow-buffer-modify '(fundamental-mode))
  700. #+end_src
  701. ** User config — Emacs vs NeLisp standalone
  702. Two entry paths, two config locations:
  703. | Entry path | Config source |
  704. |-------------------------------------------+------------------------------|
  705. | Emacs (~emacs --daemon~ + ~emacsclient~) | your existing ~init.el~ |
  706. | NeLisp standalone (~bin/anvil mcp serve~) | ~$ANVIL_CONFIG_DIR/config.el~ |
  707. Under regular Emacs nothing changes — keep putting your =setq=
  708. overrides in =init.el=. Under the NeLisp standalone path (= the
  709. Rust =anvil-runtime= binary spawned by =bin/anvil=, no =init.el= to
  710. read) anvil resolves a config file from these env vars in order:
  711. 1. =$ANVIL_CONFIG_DIR=
  712. 2. =$XDG_CONFIG_HOME/anvil= (XDG default)
  713. 3. =~/.config/anvil= (POSIX fallback)
  714. The file inside that directory is always =config.el=. Missing file
  715. is silent (= optional). Parse / eval failure is surfaced via
  716. =display-warning= but never aborts the MCP server — a broken user
  717. config must not wedge bootstrap.
  718. Example =~/.config/anvil/config.el=:
  719. #+begin_src emacs-lisp
  720. ;; Codex tasks need write access for any non-trivial dispatch.
  721. (setq anvil-orchestrator-codex-sandbox "workspace-write")
  722. ;; Truncate gain summary lines aggressively.
  723. (setq anvil-shell-filter-default-truncate-lines-at 200)
  724. #+end_src
  725. The branch on which path is in effect is fully automatic — anvil
  726. detects it via =(featurep 'nelisp)= which is true only after the
  727. NeLisp interpreter bootstrap. See =anvil-config.el= for the
  728. implementation.
  729. ** Browser module (optional)
  730. The =browser= module wraps the [[https://agent-browser.dev/][agent-browser]] CLI so an MCP
  731. client can fetch an accessibility-tree snapshot of a page in a
  732. single tool call (typically 25× fewer tokens than a raw DOM dump).
  733. #+begin_src shell
  734. npm install -g agent-browser
  735. agent-browser install # downloads Chrome for Testing if needed
  736. #+end_src
  737. Then add =browser= to =anvil-optional-modules= as shown above. The
  738. registered tools are =browser-fetch=, =browser-interact=,
  739. =browser-capture=, =browser-screenshot=, and =browser-close=. Captured
  740. pages go to =anvil-browser-capture-dir= (defcustom). Same-URL
  741. fetches within =anvil-browser-cache-ttl-sec= seconds (default 300)
  742. are served from the in-memory cache.
  743. On Windows, the agent-browser Rust binary is occasionally flagged
  744. by Defender; whitelist =%APPDATA%\npm\node_modules\agent-browser\bin\=
  745. if you hit that.
  746. ** Orchestrator module (optional)
  747. The =orchestrator= module spawns several agentic AI CLI subprocesses
  748. in parallel and exposes a terse submit / status / collect API, so the
  749. parent Claude session only spends context on task ids and final
  750. summaries — not on the intermediate tool calls each sub-task makes.
  751. Add =orchestrator= to =anvil-optional-modules=. The registered tools
  752. are:
  753. - =orchestrator-submit= — queue a batch of tasks (JSON array); each
  754. task is a plist with =name=, =provider=, =prompt= (plus optional
  755. =model=, =budget_usd=, =timeout_sec=, …). Returns a batch id
  756. without blocking.
  757. - =orchestrator-status= — return counts + slim per-task plist for a
  758. batch (or a single task).
  759. - =orchestrator-collect= — return the list of slim task results for a
  760. batch; with =wait="t"= blocks until every task is terminal.
  761. - =orchestrator-cancel= — SIGTERM / SIGKILL a running or queued task.
  762. - =orchestrator-retry= — re-submit a task under a new id.
  763. Phase 1a ships the =claude= provider (hard dependency on the
  764. =claude= CLI on =exec-path=). Phase 2 adds the =aider= provider —
  765. use =:provider 'aider= with =:model "<vendor>/<model>"= (e.g.
  766. =openai/gpt-4o-mini=, =anthropic/claude-3-5-sonnet-latest=,
  767. =gemini/gemini-2.0-flash=, =ollama/llama3=) to route a single
  768. =aider --message= shot through the multi-vendor aider CLI.
  769. gemini / ollama native adapters land in Phase 3+. Concurrency caps
  770. (=anvil-orchestrator-concurrency=,
  771. =anvil-orchestrator-per-provider-concurrency=) protect against
  772. draining a Claude MAX plan's 5-hour window; the default is 3 global
  773. and 3 per-provider.
  774. =M-x anvil-orchestrator-dashboard= opens a =tabulated-list= view of
  775. every task: keys =g= refresh, =RET= open stdout file, =k= cancel,
  776. =r= retry.
  777. Task state is persisted to =anvil-state= (ns=orchestrator) so the
  778. queue survives a daemon restart. Running tasks at shutdown are
  779. marked =failed= with a clear error on reload, since the OS pids no
  780. longer belong to Emacs.
  781. Phase 1b adds:
  782. - *Git worktree isolation*. When a task's =:cwd= is inside a git
  783. repo and =anvil-orchestrator-worktree-auto= is on (default), the
  784. claude provider receives =--worktree NAME= so N parallel tasks
  785. never stomp on the same working tree. Providers without native
  786. worktree support fall back to an =anvil-git worktree add= under
  787. =anvil-orchestrator-work-dir/worktrees/=; =:cwd= is rewritten to
  788. that path before spawn. Opt out per task with =:no-worktree t=.
  789. - *DAG scheduling*. A task may name sibling-in-batch dependencies
  790. via =:depends-on ("other-name" …)=. The pool only starts a task
  791. once every dep has reached =done=; if any dep =failed= or
  792. =cancelled=, dependents are flipped to =failed= with a
  793. "dependency X did not succeed" error. Batch-level cycle and
  794. unknown-name detection happens at submit time.
  795. - *stdout / stderr overflow*. Per-task output files over
  796. =anvil-orchestrator-output-size-cap= (default 1 MB) are rewritten
  797. as =head 256 KB= + truncation marker + =tail 256 KB=; the
  798. original byte count survives on the task record as
  799. =:stdout-bytes-original= so the dashboard and the parent session
  800. can see that a log was slimmed down.
  801. Phase 2 adds:
  802. - *aider provider*. =:provider 'aider= routes the prompt through
  803. =aider --message --yes-always --no-stream --no-check-update= with
  804. the target model selected by =:model=. Optional task fields:
  805. =:files= (positional args aider is allowed to edit),
  806. =:read-only-files= (become =--read FILE= pairs),
  807. =:subtree-only=, =:no-auto-commits=. The parser extracts the
  808. last =Commit <sha>= line into =:commit-sha= and the trailing
  809. non-diff paragraph into =:summary=. Since aider has no native
  810. worktree flag, anvil creates a =git worktree add= under
  811. =anvil-orchestrator-work-dir/worktrees/= and rewrites =:cwd=
  812. before spawn (same fallback path Phase 1b uses for every
  813. non-claude provider). Persistent extra flags go in
  814. =anvil-orchestrator-aider-extra-args=.
  815. - *Scheduled batches via anvil-cron*. Register a dispatcher
  816. function that calls =anvil-orchestrator-submit=, then schedule
  817. it with =anvil-cron-register :time "02:00"= for autonomous
  818. overnight runs. See =examples/nightly-orchestrator.org= for
  819. four end-to-end patterns (dispatch-only, dispatch-then-collect,
  820. hook-based batch-id logging, multi-provider mix) and the
  821. worker-vs-main-daemon trade-off.
  822. Requires Emacs 29+ (via =anvil-state=).
  823. ** Autoresearch module (optional)
  824. =anvil-autoresearch= is the safe, review-gated version of the
  825. "agent improves itself" loop. It does not run unbounded experiments
  826. on its own. Instead, it provides small MCP primitives that make each
  827. step inspectable:
  828. - =autoresearch-scan= — rank implementation candidates from local
  829. Web/X/YouTube summaries and =docs/design=.
  830. - =autoresearch-docstrings= / =-plan= / =-patch= — find weak MCP tool
  831. descriptions and produce dry-run rewrite candidates.
  832. - =autoresearch-docstring-apply= / =-run= / =-harvest= — apply
  833. reviewed candidates behind eval and holdout gates, reverting on
  834. failure.
  835. - =autoresearch-routing-*= — evaluate, propose, harvest, and review
  836. orchestrator provider-routing improvements.
  837. - =autoresearch-nelisp-codegen-*= — scaffold NeLisp Phase 47 codegen
  838. implementation tasks without editing the NeLisp repo from the MCP
  839. tool itself.
  840. =M-x anvil-autoresearch-dashboard= opens a =tabulated-list= view of
  841. current =autoresearch-*= orchestrator tasks. The dashboard is
  842. observational: =g= refreshes, =RET= opens the task plist; harvest,
  843. apply, and memory promotion remain explicit tool calls.
  844. ** Claude Code watchdog (optional, Linux)
  845. =anvil-claude-watchdog= watches Claude Code sessions from outside the
  846. TUI using Linux =/proc= counters and jsonl mtimes. It detects the
  847. classic "stream still alive but UI/jsonl stopped" stall, plus the
  848. State=S spinner variant where tracked MCP child processes stop
  849. advancing both =rchar= and =wchar=. Events are recorded through
  850. =anvil-state= and can trigger desktop notification.
  851. Recovery is manual by design. =M-x anvil-claude-watchdog-recover=
  852. asks for confirmation, sends =SIGKILL= to the selected stuck process,
  853. derives =claude --resume <session-id>= from the jsonl basename, and
  854. stages that command in the matching tmux pane without pressing Enter.
  855. ** Memory module (optional) — indexing auto-memory across AI CLIs
  856. The =memory= module is an opt-in, provider-agnostic index over
  857. every =.md= auto-memory file on disk, so any MCP client (Claude
  858. Code, Codex CLI, Gemini CLI, Continue, Aider, Cline, Cursor, …)
  859. can share the same long-term context.
  860. Enable it:
  861. #+begin_src emacs-lisp
  862. (add-to-list 'anvil-optional-modules 'memory)
  863. (anvil-enable) ; reload the module set
  864. #+end_src
  865. Then index everything currently on disk:
  866. #+begin_src text
  867. ;; From Emacs:
  868. M-x anvil-memory-scan
  869. ;; From an MCP client:
  870. call the `memory-scan' tool (no args)
  871. #+end_src
  872. =memory-scan= walks every directory matched by
  873. =anvil-memory-provider-paths= (default below), inserts one row per
  874. =.md= (=MEMORY.md= index files are skipped), and refreshes the FTS5
  875. body index. It is idempotent — existing =access_count= /
  876. =validity_prior= rows are preserved on conflict, so you can rerun
  877. it anytime.
  878. Default provider map (edit to add your own):
  879. #+begin_src emacs-lisp
  880. (setq anvil-memory-provider-paths
  881. '((claude . "~/.claude/projects/*/memory")
  882. (codex . "~/.codex/memories")
  883. (gemini . "~/.gemini/memories")
  884. (continue . "~/.continue/memories")
  885. (aider . "~/.aider/memories")
  886. (cline . "~/.cline/memories")
  887. (cursor . "~/.cursor/memories")
  888. (windsurf . "~/.windsurf/memories")
  889. (zed . "~/.config/zed/memories")))
  890. #+end_src
  891. Patterns may contain =*= globs. Non-existent expansions are
  892. dropped silently, so adding a provider you have not installed
  893. costs nothing. Set =anvil-memory-roots= to a fixed list when you
  894. want to override auto-detection entirely (tests / sandboxes use
  895. this).
  896. Once indexed, all of the normal tools operate across providers in
  897. a single SQLite DB (=~/.emacs.d/anvil-memory-index.db=):
  898. - =memory-search QUERY= — FTS5 full-text across every provider's
  899. memory body (=:limit=, =:type= keyword filters supported).
  900. - =memory-audit= — TTL check; =:with_urls t= pings reference
  901. URLs via =anvil-http-head=.
  902. - =memory-list= — all rows with optional =:with-decay t
  903. :sort 'decay= ranking.
  904. - =memory-save-check SUBJECT BODY= — Jaccard top-N duplicate
  905. candidates before you write a new memory (provider-agnostic).
  906. - =memory-duplicates= — cross-provider near-duplicate pairs.
  907. - =memory-promote OLD NEW-TYPE= — rename + re-index, useful
  908. when a row that started as =project_= matures into =user_=.
  909. - =memory-regenerate-index= — emit a fresh =MEMORY.md= body
  910. sorted by decay-score (read-only output; the caller decides
  911. whether to write).
  912. - =memory-add= / =memory-get= / =memory-export-md= — DB-primary
  913. write/read/export path. New memories can be inserted straight
  914. into SQLite, fetched without reading the backing =.md= file, and
  915. rendered back to a Markdown file when another AI needs file-based
  916. interchange.
  917. - =memory-session-delta= / =memory-stop-sync= — WHISPER session
  918. context. The first call returns a full decay-ranked index; later
  919. calls return only added / changed / removed memory rows until the
  920. delta grows too large.
  921. - =memory-harvest-candidates= — review-only extraction of durable
  922. memory candidates from session text or transcripts. It never
  923. persists by itself; the caller decides which candidates to save.
  924. Non-Claude clients reach these by connecting to the same anvil
  925. MCP server. The ordinary scan/search/list/audit path is read-only
  926. against provider-managed =.md= files; mutations are explicit
  927. (=memory-promote= rename, =memory-add= DB insert, or
  928. =memory-export-md= caller-driven Markdown export).
  929. *** DB location and cross-machine sharing
  930. The metadata DB defaults to =<user-emacs-directory>/anvil-memory-index.db=.
  931. You can redirect a machine to a notes repo-local DB without symlinks:
  932. #+begin_src emacs-lisp
  933. (setq anvil-memory-shared-db-roots
  934. '("~/Cowork/Notes"))
  935. #+end_src
  936. When =anvil-memory-db-path= is left at its default, the open path
  937. is resolved on first DB access by checking, in order:
  938. 1. =ANVIL_MEMORY_DB= environment variable
  939. 2. =anvil-memory-db-path= (when explicitly customized)
  940. 3. First entry of =anvil-memory-shared-db-roots= containing
  941. =.anvil-memory/anvil-memory-index.db=
  942. 4. Default =<user-emacs-directory>/anvil-memory-index.db=
  943. Use =(anvil-memory-effective-db-path)= to confirm which path the
  944. module is using.
  945. Do not merge one SQLite file between multiple machines through git.
  946. The current operational model is:
  947. - keep the =.anvil-memory/*.db= files per machine and gitignored;
  948. - use =memory-export-md= when a DB-direct memory should become a
  949. file-based artifact for other AIs;
  950. - let =memory-scan= re-index those exported files on another
  951. machine.
  952. This avoids binary merge conflicts and stale open SQLite handles in
  953. long-lived Emacs daemons.
  954. *** Memory bridge — cross-AI and mobile access
  955. The =memory-bridge= optional module puts a small localhost JSON API in
  956. front of =anvil-memory= and =anvil-worklog=. This is for clients that
  957. cannot speak the Emacs MCP server directly: browser chat UIs, mobile
  958. thin clients, another machine over Tailscale, or a read replica.
  959. #+begin_src emacs-lisp
  960. (add-to-list 'anvil-optional-modules 'memory)
  961. (add-to-list 'anvil-optional-modules 'worklog)
  962. (add-to-list 'anvil-optional-modules 'memory-bridge)
  963. (anvil-enable)
  964. (anvil-memory-bridge-start)
  965. #+end_src
  966. Default binding is =127.0.0.1:8730=. Read endpoints include
  967. =/memory/search=, =/memory/list=, =/memory/get/<name>=,
  968. =/memory/events=, =/worklog/search=, =/worklog/list=, and
  969. =/worklog/get=. Mutating memory endpoints require
  970. =Authorization: Bearer <token>=; rotate the token with
  971. =M-x anvil-memory-bridge-rotate-token=.
  972. Two thin clients live under =extensions/=:
  973. - =extensions/memory-bridge/= — Manifest V3 browser extension for
  974. Claude.ai, ChatGPT, and Gemini. =Ctrl+Alt+M= searches/injects
  975. memory; =Ctrl+Alt+S= saves selected text.
  976. - =extensions/mobile-bridge/= — dependency-free static mobile app.
  977. It stores bridge URL/token in =localStorage= and queues failed
  978. saves for replay when back online.
  979. Read-replica mode is intentionally single-writer: replicas can pull
  980. primary =memory_event= rows, but local mutating endpoints return =409=
  981. so two machines do not silently diverge.
  982. ** Worklog module (optional)
  983. The =worklog= module indexes AI work logs separately from long-term
  984. memory. It can scan legacy =capture/ai-logs-*.org= archives, but new
  985. entries are DB-primary via =worklog-add= rather than manual org
  986. appends. Search/list/get are exposed as MCP tools and also through
  987. =memory-bridge= for non-Emacs clients.
  988. Like =memory=, =worklog= is intended to use a per-machine SQLite DB.
  989. Use =worklog-export-org= when you want a human-readable org snapshot
  990. for git or cross-machine interchange. The 2026-05 develop branch also
  991. teaches the long-lived daemon to detect when its SQLite file was
  992. replaced or unlinked and reopen it automatically before the next DB
  993. operation.
  994. Typical use:
  995. #+begin_src text
  996. worklog-add(title, body)
  997. worklog-search("Doc43 autoresearch")
  998. worklog-get("anvil-worklog:db:linux-debian:2026", 1779295660)
  999. worklog-export-org(machine, year)
  1000. #+end_src
  1001. ** Git helpers
  1002. The =git= module is part of the default =anvil-modules= list. It
  1003. exposes read-only git inspection tools under the shared
  1004. =emacs-eval= server id:
  1005. - =git-repo-root= — top-level directory for a directory path, nil
  1006. outside a repo.
  1007. - =git-head-sha= — full or abbreviated HEAD commit.
  1008. - =git-branch-current= — current branch name, nil for detached.
  1009. - =git-log= — recent commits as =(hash, date, author, subject)=
  1010. objects, capped at =anvil-git-log-default-count=.
  1011. - =git-diff-names= — paths changed between FROM and TO.
  1012. - =git-diff-stats= — structured =(files, insertions, deletions)=
  1013. counts.
  1014. - =git-status= — branch / upstream / ahead / behind + buckets of
  1015. staged / modified / untracked / unmerged paths.
  1016. - =git-worktree-list= — attached worktrees with =(path, head,
  1017. branch, bare, detached)=.
  1018. The Elisp API adds =anvil-git-worktree-add= and
  1019. =anvil-git-worktree-remove= (write operations, deliberately not
  1020. exposed via MCP — =anvil-orchestrator= uses them to isolate
  1021. parallel tasks). Every call runs =git --no-pager -c
  1022. core.quotepath=false ...= so Japanese paths round-trip cleanly
  1023. and pager-configured repos don't leak terminal escapes.
  1024. ** HTTP module (optional)
  1025. The =http= module is a thin wrapper around Emacs' built-in
  1026. =url-retrieve-synchronously= that adds a SQLite-backed ETag/TTL cache
  1027. (via =anvil-state=). It is the right tool for static HTTP/JSON
  1028. resources where a full browser session would be wasteful — REST APIs,
  1029. =.json= endpoints that JS-challenge Chrome, RSS feeds, public docs
  1030. polling.
  1031. Add =http= to =anvil-optional-modules=. The registered tools are:
  1032. - =http-fetch= — GET with cache awareness. Within
  1033. =anvil-http-cache-ttl-sec= (default 300 s) the response is served
  1034. without any network call; otherwise a conditional GET with
  1035. =If-None-Match= / =If-Modified-Since= is issued and a =304= refreshes
  1036. the cached entry with zero body transfer. Retries =5xx= / =408= /
  1037. =429= with exponential backoff (=Retry-After= honoured on 429).
  1038. - =http-head= — HEAD probe for cheap metadata checks; never cached.
  1039. - =http-cache-clear= — drop a single URL or flush the whole http
  1040. namespace.
  1041. Scheme guard: only =http= / =https= are accepted
  1042. (=anvil-http-allowed-schemes=), so =file://= / =javascript:= are
  1043. refused. =url-max-redirections= is clamped to 5 per call, well below
  1044. Emacs' default 30.
  1045. Requires Emacs 29+ (for the built-in =sqlite-*= used by =anvil-state=).
  1046. * Client setup — connecting your AI to Anvil
  1047. After Anvil is running inside Emacs, you need to register it as
  1048. an MCP server in your AI client (Claude Desktop, Claude Code CLI, Codex CLI,
  1049. or any other MCP-compatible client).
  1050. The bridge is a small shell script (=anvil-stdio.sh=) that speaks
  1051. JSON-RPC on stdio and forwards calls to your running Emacs daemon
  1052. via =emacsclient=. Install it once per machine:
  1053. #+begin_src
  1054. M-x anvil-server-install
  1055. #+end_src
  1056. By default this places =anvil-stdio.sh= in your =user-emacs-directory=
  1057. (typically =~/.emacs.d/=). You can change the destination with
  1058. =M-x customize-variable RET anvil-server-install-directory=.
  1059. *Prerequisite:* Emacs must be running as a daemon
  1060. (=server-start= or =emacs --daemon=). Anvil connects to it via
  1061. =emacsclient=.
  1062. ** Claude Desktop
  1063. Config file location:
  1064. | OS | Path |
  1065. |-------------------+---------------------------------------------------------------------------------------------|
  1066. | macOS | =~/Library/Application Support/Claude/claude_desktop_config.json= |
  1067. | Linux | =~/.config/Claude/claude_desktop_config.json= |
  1068. | Windows (regular) | =%APPDATA%\Claude\claude_desktop_config.json= |
  1069. | Windows (UWP) | =%LOCALAPPDATA%\Packages\Claude_<id>\LocalCache\Roaming\Claude\claude_desktop_config.json= |
  1070. Anvil currently registers tools under *two* MCP server-ids
  1071. internally — =anvil= (eval / IDE) and =emacs-eval= (file, org,
  1072. buffer, worker, ...). Most clients show one tool list per
  1073. =mcpServers= entry, so you need *two entries* pointing at the
  1074. same script with different =--server-id= values to expose every
  1075. tool. (A future release will collapse these into a single
  1076. server-id; for now, two entries is the supported setup.)
  1077. *** macOS / Linux
  1078. #+begin_src json
  1079. {
  1080. "mcpServers": {
  1081. "anvil": {
  1082. "command": "/path/to/.emacs.d/anvil-stdio.sh",
  1083. "args": [
  1084. "--server-id=anvil",
  1085. "--init-function=anvil-enable",
  1086. "--stop-function=anvil-disable"
  1087. ]
  1088. },
  1089. "anvil-emacs-eval": {
  1090. "command": "/path/to/.emacs.d/anvil-stdio.sh",
  1091. "args": [
  1092. "--server-id=emacs-eval"
  1093. ]
  1094. }
  1095. }
  1096. }
  1097. #+end_src
  1098. The second entry connects to the already-running daemon and
  1099. exposes the file/org/buffer/worker tools. =--init-function= is
  1100. only needed on one entry — the first connection enables anvil
  1101. and registers tools under both server-ids.
  1102. If your Emacs daemon uses a non-default socket directory, add
  1103. =--socket=/path/to/server= to the =args= of *both* entries.
  1104. *** Windows
  1105. Windows needs Git Bash to execute the shell script:
  1106. #+begin_src json
  1107. {
  1108. "mcpServers": {
  1109. "anvil": {
  1110. "command": "C:\\Program Files\\Git\\bin\\bash.exe",
  1111. "args": [
  1112. "C:/Users/<you>/.emacs.d/anvil-stdio.sh",
  1113. "--server-id=anvil",
  1114. "--init-function=anvil-enable",
  1115. "--stop-function=anvil-disable"
  1116. ]
  1117. },
  1118. "anvil-emacs-eval": {
  1119. "command": "C:\\Program Files\\Git\\bin\\bash.exe",
  1120. "args": [
  1121. "C:/Users/<you>/.emacs.d/anvil-stdio.sh",
  1122. "--server-id=emacs-eval"
  1123. ]
  1124. }
  1125. }
  1126. }
  1127. #+end_src
  1128. Restart Claude Desktop after editing the config.
  1129. ** Claude Code (CLI)
  1130. The CLI stores its config in =~/.claude.json= mixed with chat
  1131. history and other state — *do not overwrite the whole file*.
  1132. Use the =claude mcp add= command to add the server entries.
  1133. Run *both* commands to expose all tools:
  1134. #+begin_src sh
  1135. claude mcp add -s user -t stdio anvil -- \
  1136. ~/.emacs.d/anvil-stdio.sh \
  1137. --server-id=anvil \
  1138. --init-function=anvil-enable \
  1139. --stop-function=anvil-disable
  1140. claude mcp add -s user -t stdio anvil-emacs-eval -- \
  1141. ~/.emacs.d/anvil-stdio.sh \
  1142. --server-id=emacs-eval
  1143. #+end_src
  1144. On Windows, replace the script path with the Git Bash invocation
  1145. shown above (=command= = bash.exe, first =arg= = the script path).
  1146. ** Codex CLI
  1147. Codex CLI can use the same MCP stdio bridge. Register both server
  1148. entries, mirroring the Claude Code setup: one =anvil= entry that
  1149. initializes the daemon, and one =anvil-emacs-eval= entry that exposes
  1150. file/org/buffer/worker plus optional tools such as =shell-run=,
  1151. =shell-filter=, =context-compress=, =context-retrieve=, and
  1152. =context-stats=.
  1153. If you manage Codex MCP servers through =codex mcp add=:
  1154. #+begin_src sh
  1155. codex mcp add anvil -- \
  1156. ~/.emacs.d/anvil-stdio.sh \
  1157. --server-id=anvil \
  1158. --init-function=anvil-enable \
  1159. --stop-function=anvil-disable
  1160. codex mcp add anvil-emacs-eval -- \
  1161. ~/.emacs.d/anvil-stdio.sh \
  1162. --server-id=emacs-eval
  1163. #+end_src
  1164. If your Codex version uses project/global =config.toml= instead,
  1165. create equivalent stdio MCP entries with the same command and args.
  1166. The important part is that the =emacs-eval= entry is present; the
  1167. compression tools live there.
  1168. ** Optional: register the worker pool too
  1169. For workloads that benefit from out-of-band execution (large
  1170. tangles, multi-MB org scans, byte-compile), Anvil's worker module
  1171. runs sub-Emacs daemons. You can register one as a separate MCP
  1172. server so the AI client can address it directly:
  1173. #+begin_src json
  1174. {
  1175. "mcpServers": {
  1176. "anvil": { ... main daemon ... },
  1177. "anvil-worker": {
  1178. "command": "/path/to/.emacs.d/anvil-stdio.sh",
  1179. "args": [
  1180. "--socket=/path/to/.emacs.d/server/anvil-worker",
  1181. "--server-id=anvil-worker"
  1182. ]
  1183. }
  1184. }
  1185. }
  1186. #+end_src
  1187. Most users do not need this — Anvil's =worker= module dispatches
  1188. heavy ops automatically over the main connection.
  1189. ** Verifying the connection
  1190. Inside Emacs:
  1191. | Command | What it shows |
  1192. |-------------------------------+------------------------------------------------|
  1193. | =M-x anvil-describe-setup= | Tools, resources, and example client config |
  1194. | =(anvil-server-status)= | Main MCP server state (running / stopped) |
  1195. | =(anvil-worker-status)= | Worker pool state |
  1196. In your AI client: ask the agent to list its tools, or invoke a
  1197. read-only one like =anvil-host-info=. If the call returns, the
  1198. bridge is working.
  1199. * Teaching your AI to use Anvil — AGENTS.md / CLAUDE.md guidance
  1200. Connecting Anvil only exposes the tools — your AI agent still
  1201. needs to *prefer* them over its built-in =Read= / =Edit= / =Write=
  1202. to realize the token savings described above. Most LLM clients
  1203. read a project-level instructions file (Codex uses =AGENTS.md=,
  1204. Claude Code uses =CLAUDE.md=, Cursor uses =.cursorrules=, etc.).
  1205. Drop the snippet below into yours.
  1206. ** Recommended snippet (=AGENTS.md= / Claude Code =CLAUDE.md=)
  1207. #+begin_src markdown
  1208. ## File editing
  1209. Prefer Anvil MCP tools over the built-in Read/Edit/Write
  1210. whenever they apply. They ship only the delta, batch multiple
  1211. edits in one round trip, and avoid full-file reads.
  1212. - `anvil-file-batch` — 3+ edits to the same file (collapse into one call)
  1213. - `anvil-file-replace-string` / `anvil-file-replace-regexp` —
  1214. pinpoint replacement; no need to read the whole file first
  1215. - `anvil-file-insert-at-line` / `anvil-file-delete-lines` /
  1216. `anvil-file-append` — localized line-level operations
  1217. Use the built-in `Edit` only for small one-off changes. For 3 or
  1218. more edits to the same file, always use `anvil-file-batch`.
  1219. ## org-mode
  1220. For section moves, refile, splits, or reading a single heading
  1221. from a large org file, use `anvil-org-*` tools instead of
  1222. Read+Write. They are 10–20× cheaper in tokens.
  1223. - `anvil-org-read-headline` — read a single subtree
  1224. - `anvil-org-read-outline` — outline view without bodies
  1225. - `anvil-org-edit-body` / `anvil-org-rename-headline` /
  1226. `anvil-org-update-todo-state` — targeted org edits
  1227. ## Heavy operations — worker dispatch
  1228. Long-running Emacs ops (large tangles, byte-compile, multi-MB
  1229. org scans, full-tree searches) must not run on the main daemon —
  1230. they block every other tool call. Dispatch them through the
  1231. worker pool instead.
  1232. - Elisp called from inside Anvil: prefer `anvil-worker-call` over
  1233. raw `eval` for anything that may exceed ~1s.
  1234. - If the worker is registered as its own MCP server (see README
  1235. "Optional: register the worker pool too"), heavy `eval` calls
  1236. should target `mcp__anvil-worker__eval` directly so the main
  1237. session stays responsive.
  1238. Symptom that you should have used the worker: the main MCP
  1239. session stops accepting tool calls for several seconds.
  1240. ## Scheduled tasks (cron)
  1241. If `anvil-cron` tasks are configured (lint, health checks, batch
  1242. indexers, etc.), do not re-implement their work ad hoc. Inspect
  1243. and trigger them through the cron MCP tools:
  1244. - `anvil-cron-list` — what tasks exist and their schedules
  1245. - `anvil-cron-status` — last run time, status, recent failures
  1246. - `anvil-cron-run` — fire a registered task on demand
  1247. Before writing a new ad-hoc script, check `anvil-cron-list` —
  1248. the job may already be defined.
  1249. ## Context and output compression
  1250. When command output or retrieved context is long, compress it before
  1251. feeding it back into the main reasoning loop.
  1252. - Use `shell-run` for shell commands whose stdout can be filtered
  1253. automatically. It returns compressed stdout plus a `tee-id`; recover
  1254. the raw output with `shell-tee-get` only when the compressed view is
  1255. insufficient.
  1256. - Use `context-compress` for non-shell text: API JSON, RAG snippets,
  1257. web/article extracts, logs from another tool, diffs, or code
  1258. excerpts. Set `store=true` when the raw text may be needed later;
  1259. recover it with `context-retrieve` and the returned `ccr-id`.
  1260. - Use `context-stats` / `shell-gain` to inspect savings instead of
  1261. guessing whether the compression layer is helping.
  1262. Do not use compressed views as the only source of truth for legal,
  1263. financial, safety-critical, or exact numeric work. Retrieve the raw
  1264. context before making claims that depend on exact wording or values.
  1265. #+end_src
  1266. ** Self-reinforcement rule (optional)
  1267. To keep the agent on track over long sessions, add a
  1268. self-correction trigger:
  1269. #+begin_src markdown
  1270. ## MCP tool self-reinforcement
  1271. If during a task you notice any of the following, switch to
  1272. the appropriate Anvil tool before continuing:
  1273. - The same elisp pattern is being written twice in one session
  1274. - Three or more `anvil-eval` calls were issued for one logical edit
  1275. (a single `anvil-file-batch` would have sufficed)
  1276. - Repeated full-file Reads of the same large file
  1277. - A heavy elisp op blocked the main session — should have been
  1278. routed via `anvil-worker-call` / `mcp__anvil-worker__eval`
  1279. Course-correct mid-task — do not wait until the end.
  1280. #+end_src
  1281. ** Why this matters
  1282. Without explicit guidance, agents default to the lowest-common-
  1283. denominator tools (=Read=, =Edit=, =Write=) regardless of which
  1284. MCP servers are connected. The savings table at the top of this
  1285. README assumes the agent actually *picks* the Anvil tool — and
  1286. that decision is driven by your instructions file, not by Anvil
  1287. itself.
  1288. * FAQ — how does this compare to…?
  1289. ** …claude-code-ide?
  1290. They solve different problems and coexist well. =claude-code-ide=
  1291. brings Claude Code's interactive UI /into/ Emacs via eat; its MCP
  1292. surface is primarily IDE-oriented (xref / diagnostics / buffer
  1293. metadata). For file edits it leans on Claude Code's built-in Read /
  1294. Edit / Write against the filesystem.
  1295. Anvil goes the opposite direction: it's a standalone MCP server
  1296. exposing /Emacs itself/ — file ops, org primitives, worker dispatch,
  1297. elisp introspection — to any MCP client. In practice I run both:
  1298. claude-code-ide for the inline Claude session inside Emacs, and anvil
  1299. as a separate MCP server that both claude-code-ide /and/ the
  1300. standalone ~claude~ CLI can call into.
  1301. ** …an "arbitrary elisp eval" MCP?
  1302. Single-eval MCPs (e.g. [[https://github.com/steveyegge/efrit][efrit]]) are philosophically pure: zero
  1303. client-side intelligence, the agent writes elisp for every task. The
  1304. trade-off is /permission granularity/ — a single eval tool can't be
  1305. marked =:read-only=, so you can't auto-approve reads while gating
  1306. writes.
  1307. Anvil's default install exposes ~40 named primitives. Optional modules add their own when enabled (max upper bound depends on which modules you load)., each registered with an explicit
  1308. =:read-only= hint where applicable. In Claude Code that maps cleanly
  1309. onto =/permissions=: auto-approve ~org-read-outline~, ~file-read~,
  1310. ~elisp-describe-function~; force a prompt on ~file-batch~,
  1311. ~org-edit-body~, ~file-replace-string~. Anvil still ships
  1312. ~emacs-eval~ and ~emacs-eval-async~ as escape hatches — they just
  1313. aren't the 80% path.
  1314. ** …calling =emacsclient= from bash?
  1315. That was my starting point too. Reasons I moved off it:
  1316. - *No permission granularity.* Every =emacsclient -e '...'= is opaque
  1317. to =/permissions= — it's all "Bash". With MCP each named tool
  1318. registers a =:read-only= hint so the client can auto-approve reads
  1319. and prompt on writes.
  1320. - *No schema.* The agent has to remember the elisp surface from
  1321. prompt; MCP publishes the tool list in the system schema so the
  1322. right tool gets picked without being reminded each turn.
  1323. - *Escape hell.* Multi-line elisp through bash quoting is famously
  1324. fragile, especially with Japanese paths or regex.
  1325. - *Structured returns.* MCP tools return typed JSON; =emacsclient=
  1326. returns a printed sexp you have to parse.
  1327. Same Emacs underneath; the MCP layer is just a typed, permissioned
  1328. facade.
  1329. ** …org-mcp?
  1330. [[https://github.com/laurynas-biveinis/org-mcp][Org-mcp]] focuses tightly on org editing primitives over MCP. Anvil
  1331. bundles those primitives (with extensions and bug fixes) and adds the
  1332. file / subprocess / heavy-op / worker-pool layers, so a single MCP
  1333. server covers an entire workflow rather than just org. If you're
  1334. already happy with org-mcp on its own, anvil isn't a replacement —
  1335. it's the same idea wearing a bigger coat.
  1336. ** …I've never touched Emacs before. Is that OK?
  1337. Yes. Anvil is an MCP server that runs as a background daemon — you
  1338. never have to open an Emacs window. Keep using whatever editor you
  1339. already use (VSCode / Cursor / Neovim / Claude Code / Codex CLI itself).
  1340. What you actually need:
  1341. - Install Emacs once and confirm =emacs --version= works
  1342. - Run it as =--fg-daemon= (a launcher script ships with the repo)
  1343. - Add a single block to your AI client's MCP config
  1344. A full walkthrough lives in [[https://github.com/zawatton/anvil.el#for-non-emacs-users--what-setup-costs-you][For non-Emacs users]]. No Emacs Lisp
  1345. knowledge required to capture the AI-token savings.
  1346. * Internals — bridge + worker pool
  1347. #+begin_example
  1348. Claude / Codex / GPT / Local LLM
  1349. |
  1350. MCP (JSON-RPC via stdio)
  1351. |
  1352. anvil-stdio.sh (bridge)
  1353. |
  1354. emacsclient → Emacs daemon
  1355. |
  1356. anvil-server (dispatcher)
  1357. |
  1358. +---------+---------+
  1359. | main | worker | (worker pool: heavy ops
  1360. | daemon | daemons | run in isolated sub-Emacs)
  1361. +---------+---------+
  1362. #+end_example
  1363. * Platform Support
  1364. The current CI matrix runs on GNU Emacs 31.1. The package metadata
  1365. continues to declare its compatibility floor separately.
  1366. | Platform | Status |
  1367. |----------------------+-----------|
  1368. | Linux (native Emacs) | Supported |
  1369. | macOS (native Emacs) | Supported |
  1370. | Windows (native) | Supported |
  1371. | WSL | Supported |
  1372. * How to help shape what comes next
  1373. If something in this README resonates with you, the most useful signals are these four:
  1374. - A *Star* on the repo — it lets me see what kind of context lands.
  1375. - An *Issue* describing your concrete org / MCP workflow — that decides which primitives I add next.
  1376. - Honest comparisons with [[https://github.com/laurynas-biveinis/org-mcp][org-mcp]] or any existing MCP shim I might have unknowingly reinvented.
  1377. - Tool naming and granularity feedback — is there "too many small ops," or is it "about right"? Your gut take helps a lot.
  1378. * Contributing
  1379. Issues, feature requests, and pull requests are welcome at
  1380. [[https://github.com/zawatton/anvil.el]].
  1381. If you find Anvil useful, consider [[https://github.com/sponsors/zawatton][sponsoring the project]].
  1382. * Related Packages
  1383. These packages are also developed by the same author:
  1384. | Package | Description | Repo |
  1385. |---------+-------------+------|
  1386. | [[https://github.com/zawatton/async-installer][async-installer]] | Non-blocking GitHub package installer with commit pinning | [[https://github.com/zawatton/async-installer][GitHub]] |
  1387. | [[https://github.com/zawatton/eat-windows-pty][eat-windows-pty]] | ConPTY support for emacs-eat on native Windows | [[https://github.com/zawatton/eat-windows-pty][GitHub]] |
  1388. | [[https://github.com/zawatton/org-draw][org-draw]] | Excalidraw and tldraw integration for org-mode | [[https://github.com/zawatton/org-draw][GitHub]] |
  1389. | [[https://github.com/zawatton/catchall-box][catchall-box]] | UUID-based file management for org-mode | [[https://github.com/zawatton/catchall-box][GitHub]] |
  1390. | [[https://github.com/zawatton/emacs-skkserv][emacs-skkserv]] | Pure Elisp skkserv for Japanese input (ddskk, Google IME, MeCab) | [[https://github.com/zawatton/emacs-skkserv][GitHub]] |
  1391. | [[https://github.com/zawatton/my-locate-library][my-locate-library]] | Fast load-path index for accelerated require/load | [[https://github.com/zawatton/my-locate-library][GitHub]] |
  1392. * License
  1393. GPL-3.0. See [[file:LICENSE][LICENSE]].
  1394. * Acknowledgments
  1395. - [[https://github.com/laurynas-biveinis/mcp-server-lib.el][mcp-server-lib.el]] by Laurynas Biveinis — the MCP protocol foundation
  1396. - [[https://github.com/laurynas-biveinis/org-mcp][org-mcp]] by Laurynas Biveinis — org primitives extended and integrated into =anvil-org=
  1397. - [[https://github.com/manzaltu/claude-code-ide.el][claude-code-ide.el]] by Manzaltu — IDE integration inspiration

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.