agentledger — плагин для Claude Code: отчёты и установка
Плагин agentledger для Claude Code сохраняет отчёты агента в приватном git-хранилище и открывает их для просмотра. Через страницу можно комментировать текст и задавать вопросы сессии, которая подготовила отчёт.
Apache-2.0 ★ 106 обновлён 2026-11-16
/plugin marketplace add SecretSettler/AgentLedger
/plugin install agentledger@agentledgerЧто делает agentledger
agentledger публикует отчёты в Markdown как версии в локальном git-хранилище. Команда agentledger open открывает страницу отчёта: разделы ## можно комментировать и сравнивать между версиями. Комментарии сохраняются через локальный сервер, GitHub API или экспортированный CSV.
Выделенный фрагмент можно отправить на разбор с помощью Ask. Вопрос и ветка обсуждения передаются сессии, создавшей отчёт; для Claude Code она возобновляется как ответвление, не меняя исходную сессию. После комментариев агент отвечает в ветках и публикует следующую версию. Хранилище включает отчёты и связанные с ними стенограммы, поэтому его следует держать приватным. Для установки CLI нужен Python 3.9+.
Какие задачи решает
- сохранить отчёт агента как версию в git-хранилище
- оставить комментарии к разделам и фрагментам отчёта
- задать вопрос по тексту сессии, которая его написала
- обработать замечания и опубликовать исправленную версию
Примеры запросов агенту
- Оформи результаты этой работы как отчёт.
- Открой отчёт через
/agentledger:open. - Разбери замечания к отчёту через
/agentledger:review.
Как установить agentledger
Через маркетплейс плагинов
/plugin marketplace add SecretSettler/AgentLedger/plugin install agentledger@agentledgerПо шагам, с командами для каждой платформы: Плагины Claude Code: маркетплейсы, установка и как собрать свой
Вопросы об agentledger
Как установить agentledger в Claude Code?
Выполни команды по порядку: /plugin marketplace add SecretSettler/AgentLedger, затем /plugin install agentledger@agentledger.
Что делает agentledger?
Плагин сохраняет отчёты агента в приватном git-хранилище, показывает их на веб-странице и передаёт вопросы по отчёту исходной сессии. Агент может обработать комментарии и выпустить следующую версию.
Что нужно для работы agentledger?
Для установки CLI нужен Python 3.9+. Отчёты и связанные стенограммы хранятся в git-хранилище, которое следует держать приватным.
Исходный текст
SKILL.md · Apache-2.0
<p align="center">
<picture>
<source media="(prefers-color-scheme: dark)" srcset="docs/images/banner-dark.png">
<img alt="AgentLedger" src="docs/images/banner-light.png" width="720">
</picture>
</p>
<p align="center"><b>Filed by your agent. Reviewed by you. Answered by the session that wrote it.</b></p>
<p align="center">
<a href="#quick-start">Quick start</a> ·
<a href="#install">Install</a> ·
<a href="#how-it-works">How it works</a> ·
<a href="#reviewing">Reviewing</a> ·
<a href="#guide">Guide</a> ·
<a href="#reference">Reference</a>
</p>
<p align="center">
<img alt="Python 3.9+" src="https://img.shields.io/badge/python-3.9%2B-2d5fd3">
<img alt="Zero dependencies" src="https://img.shields.io/badge/dependencies-0-1d7f55">
<img alt="Claude Code plugin" src="https://img.shields.io/badge/Claude%20Code-plugin-1f1e1b">
<img alt="Codex skill" src="https://img.shields.io/badge/Codex-skill-1f1e1b">
<img alt="Pi skill" src="https://img.shields.io/badge/Pi-skill-1f1e1b">
<img alt="Antigravity skill" src="https://img.shields.io/badge/Antigravity-skill-1f1e1b">
<img alt="License Apache-2.0" src="https://img.shields.io/badge/license-Apache--2.0-77736a">
</p>
Agents now produce long write-ups: benchmark comparisons, audits, investigations. Reviewing them means scrolling a
wall of text, losing track of what changed between drafts, and asking follow-up questions in a chat that has long
forgotten how the numbers were made.
AgentLedger files every report your agent writes into **your own private git store**, renders it as a page you can
annotate, and sends your questions **back to the session that wrote it**, so the answer comes from the agent's memory
of the work and from its trace, not from a fresh guess.
<p align="center">
<img alt="Select a passage, press Ask, and the agent answers in the thread" src="docs/images/demo.gif" width="900"><br>
<sub>Select a passage → <b>Ask</b> → the agent that wrote the report answers in the thread. (Demo data.)</sub>
</p>
## Quick start
```sh
curl -fsSL https://raw.githubusercontent.com/SecretSettler/AgentLedger/main/install.sh | sh
```
That installs the CLI, creates a private store at `~/agentledger-store` (or links yours: `... | sh -s -- ~/my-store-clone`)
and installs the skill for **Claude Code**, **Codex**, **Pi** and **Antigravity**. Then, in any repository, just ask your agent:
> write this up as a report
and review it:
```sh
agentledger open # http://localhost:8765, comment on any line, Ask about any passage
```
When you've commented, tell the agent *"handle the review comments on harness-vs-paper"*. It answers each thread,
publishes v2 with the fixes, and marks what it resolved. To bring someone in, tell it *"share harness-vs-paper with
Alice"*: it asks who Alice is if it must, then gives a teammate the steps to join the store (Sync in the page sends
and fetches comments), or packs the one report for someone outside it with credentials removed.
Want to look around first? `agentledger demo` builds a sample store and opens it.
## Install
### 1. Let your agent do it
Paste this into Claude Code, Codex, Pi or Antigravity:
> Install AgentLedger from https://github.com/SecretSettler/AgentLedger: run
> `curl -fsSL https://raw.githubusercontent.com/SecretSettler/AgentLedger/main/install.sh | sh`
> (append `-s -- <path>` if I already have a store clone), make sure `agentledger` is on my PATH,
> then run `agentledger demo --no-open` and tell me the URL.
### 2. Claude Code plugin
```text
/plugin marketplace add SecretSettler/AgentLedger
/plugin install agentledger@agentledger
```
On Claude Code 2.1.275 or later, one step does both: `/plugin install agentledger --marketplace SecretSettler/AgentLedger`.
The plugin adds the skill plus `/agentledger:report`, `/agentledger:review`, `/agentledger:share` and `/agentledger:open`; on first use the
skill offers to install the CLI.
### 3. Codex, Pi and Antigravity
`install.sh` (or `agentledger setup`) installs the skill for every supported harness by default (pass `--agent claude|codex|pi|antigravity` to target specific ones):
- **Codex:** `~/.agents/skills/agentledger/` (older Codex versions read `~/.codex/skills/`; copy [`skills/agentledger`](skills/agentledger) there).
- **Pi:** `$PI_CODING_AGENT_DIR/skills/agentledger/` when `PI_CODING_AGENT_DIR` is set, else `~/.pi/agent/skills/agentledger/`.
- **Antigravity:** `$ANTIGRAVITY_HOME/config/skills/agentledger/` (or `$GEMINI_CLI_HOME/config/skills/agentledger/`), else `~/.gemini/config/skills/agentledger/`.
### 4. By hand
```sh
pipx install git+https://github.com/SecretSettler/AgentLedger # or: pip install --user ...
agentledger setup [path-to-your-store-clone] [--agent ...] # creates ~/agentledger-store if you have none
```
**Keep the store private.** It holds your reports and the transcripts behind them. A new one is a local git repo; give
it a private remote, e.g. `gh repo create my-agent-ledger --private --source ~/agentledger-store --push`.
## How it works
<p align="center"><img alt="How AgentLedger works" src="docs/images/how-it-works.png" width="900"></p>
1. **Publish.** The agent writes Markdown and runs `agentledger publish <repo>/<topic> draft.md --link-session auto`.
The CLI files it as the next version (`v001`, `v002`, …), records the repo, branch and commit it describes, and
links the session that wrote it (its id only). With `--trace auto` it also shares a reviewed, redacted copy of that
session (see [Writing reports](#writing-reports)).
2. **Review.** `agentledger open` serves the store on `localhost` and opens the report. Every `##` section is a module
you can comment on, link to and compare across versions.
3. **Comment.** Select any text and press **Comment**. Comments are saved into the version's `comments.csv`, through
the local server, the GitHub API, or an exported CSV.
4. **Ask.** Select text and press **Ask**. Your question, the quote and the thread become the prompt. The session that
wrote the report answers: Claude Code and Pi resume a fork of it (`claude --resume --fork-session`, `pi --fork`, so
your original session is untouched), while Codex and Antigravity resume it in place (`codex exec resume`,
`agy --conversation`). That happens once per version: every later
question on the version, in any thread, continues the same review session, so the agent remembers the review so far.
Without the session, the first question starts the review session as a fresh run that answers from the trace. The
agent reads first and runs programs only to compute what is not written down (see [Asking](#asking)).
5. **Revise.** The agent runs `agentledger comments list --status waiting`, replies in place, and publishes the next
version with `--resolves`. Changed modules are flagged; resolved threads point at the version that fixed them.
Who can do what:
| | On the machine serving it (`agentledger open`) | Shared (`serve --share`, a static copy) |
|---|:---:|:---:|
| Read, navigate versions and sub-reports | ✓ | ✓ |
| Comment | ✓ | ✓ |
| Ask the agent | ✓ | |
Someone else can also read a report **on their own machine and ask their own AI**: send them one report with
`agentledger share` (below), or give them a clone of the store. Their agent answers from the report and its traces,
since your original session only exists on your machine.
The store is a plain git repo with one fixed layout. Only the CLI writes into `projects/`, and `agentledger check`
flags anything out of place:
```
~/agentledger-store/
agentledger.json, index.html (dashboard), manifest.json
projects/<project>/<report>/
v001/ report.md · meta.json · comments.csv · traces/ · index.html
v002/
<sub-report>/v001/ …
```
## Reviewing
<table>
<tr>
<td width="50%"><img alt="A report with the timeline rail and the navigator pad" src="docs/images/report.png"></td>
<td width="50%"><img alt="An answered Ask thread in the review panel" src="docs/images/ask-answer.png"></td>
</tr>
<tr>
<td><b>Report.</b> Modules flagged <i>changed since v1</i>; the timeline rail on the left (drag its knob to scrub); the navigator pad with versions, sub-reports and a minimap.</td>
<td><b>Review panel.</b> Threads anchored to the quoted text, agent answers inline, Export / Import / Copy CSV, <i>Copy for agent</i>.</td>
</tr>
<tr>
<td><img alt="The dashboard" src="docs/images/dashboard.png"></td>
<td><img alt="The project map" src="docs/images/map.png"></td>
</tr>
<tr>
<td><b>Dashboard.</b> Every project and report with its version chain, open threads, threads waiting on the agent, activity.</td>
<td><b>Project map</b> (<kbd>m</kbd>). Every report in the project; each circle is a version.</td>
</tr>
</table>
- **Sync:** the panel's **Sync** button saves your comments, pulls what others pushed, commits (`review: <report> vN
by <you>`) and pushes the store, so everyone who can read it sees the review on GitHub or after their own Sync.
It is the same as `agentledger sync`, and only the machine running `agentledger serve` gets it: it commits and
pushes as you. A push that needs a password fails with git's message instead of waiting; run `agentledger sync`
once in a terminal to set up credentials.
- **Trace citations:** a number that links to `trace:run.log#L24` opens those lines of the trace, highlighted, with
more context on demand, **Copy reference** (for a comment or your own AI) and **Ask about these lines**. The cited
lines are kept in the page, so this works from a shared copy or a file opened from disk too.
- **Comment / Ask:** select text, or use the icon on a module heading. Threads have go, reply, **Reply & ask**, resolve,
edit and delete. Once the agent has answered, the thread is a conversation: type the next question in the box under
the answer and press <kbd>Enter</kbd> (<kbd>Shift</kbd>+<kbd>Enter</kbd> for a new line, **Reply only** to save
without asking).
- **Navigate without scrolling:** the rail is the report as a vertical timeline; the round stick at the bottom right
is a joystick (drag up or down to scroll, click to open the pad); the version chain opens any version at the same module.
- **Shortcuts:** <kbd>j</kbd>/<kbd>k</kbd> modules, <kbd>[</kbd>/<kbd>]</kbd> versions, <kbd>c</kbd> comment,
<kbd>a</kbd> ask, <kbd>p</kbd> panel, <kbd>m</kbd> map, <kbd>n</kbd> pad, <kbd>d</kbd> dashboard, <kbd>?</kbd> help.
- Dark mode follows your system (or the toggle in the top bar). Unsaved comments live in the browser until saved.
## Guide
### Writing reports
The skill tells the agent all of this; it's here for when you write one yourself (`agentledger template` prints a skeleton).
- `# Title` first; front matter `summary:` (the answer in one or two sentences), `about:`, `tags:`.
- One `##` per module with a stable id, `## Results {#results}`, so comments and change tracking follow it across
versions. Flag modules for a human check with `## Results {#results status=needs-review}`.
- Evidence next to every claim. Images and data: `--asset <path>`; they carry over to later versions.
- Sub-reports: publish to a longer id, `agentledger publish repo/topic/part part.md --link-session auto`.
- Sessions: `--link-session auto|PATH|ID` (required) links the session that wrote the report, so Ask on this machine
continues it. `auto` is the session running the command (`CLAUDE_CODE_SESSION_ID`, `CODEX_THREAD_ID`,
`PI_SESSION_FILE` / `PI_SESSION_ID`, `ANTIGRAVITY_CONVERSATION_ID`), else the
most recently active one for the directory (never one of Ask's own); publish prints which. Only the id is recorded.
- Traces are what a version shares with everyone who can read the store. `--trace auto` shares the linked session as
a reviewed copy: `agentledger trace prepare <id> --link-session auto` keeps only the conversation (no system text,
attached files, reasoning or account ids) and redacts secrets (values from `.env` files and credential-named
environment variables, and common key formats), the agent reviews and edits the copy (or, from the command line,
`agentledger trace review <id> --agent claude|codex|pi|antigravity` has Claude Code or Codex edit it in its sandbox
or Pi / Antigravity list what to change), `agentledger trace approve <id>` checks it again and records it, and publish
refuses a copy that is missing, unapproved or changed since.
`--trace <path>` attaches any log or folder as it is.
- HTML reports keep their own CSS (from `<head>` too) and their own `<h1>`, in a 980px column
(`<meta name="agentledger:width" content="1100">` sets another); the reading typography is for Markdown only. Scope
the CSS to `.al-module`, never `html`, `body` or `:root`, and put each module under a top-level `<h2 id>`.
Stylesheets and fonts need `--allow-scripts`; otherwise only inline `style=` survives the sanitiser.
### Asking
- `agentledger open` (or `serve`) enables Ask when `claude`, `codex`, `pi` or `agy` (Antigravity) is installed. The report's own session is used
when its transcript is on this machine; otherwise `--ask claude|codex|pi|antigravity` picks the agent, and `--ask-cmd "<cmd>"` plugs
in anything that reads a prompt on stdin and prints an answer.
- From the terminal: `agentledger ask <comment-id>`. `--print-prompt` shows exactly what the agent receives.
- **Read first, compute when needed.** The agent answers from the report, its traces and the repository with Read, Grep
and Glob (Pi: `read`, `grep`, `find`, `ls`; Codex / Antigravity: read-only inspection). It runs programs only when searching cannot settle the question or the answer
is a derived value (a count, a sum, a script re-run on the data), and then lists the commands and their output.
- **The sandbox.** Programs run in the agent's own sandbox: Claude Code's Bash sandbox or a Codex permissions profile
(Pi runs offline with read-only tools only; Antigravity runs with `--sandbox` in read-only mode).
The agent can read the whole machine except confidential files and write only to a per-version scratch folder under
the temp directory; every other tool stays off. When the sandbox cannot start, cannot be verified or would be
widened, Ask only reads, and confidential files stay unreadable. `serve --ask-read-only`, `ask --read-only` or
`AGENTLEDGER_ASK_SANDBOX=off` force read-only mode.
- **Follow-ups.** Ask again in the same thread as often as you like. Every question sends the whole thread, earlier
answers included, and continues the version's review session, so the agent keeps the context of the conversation.
- Answers are saved as agent replies in `comments.csv`, so they are versioned with the report.
- Each version's review session is named `AgentLedger: <report> v<N>` and shows up in `claude --resume`, Pi's session
picker and the IDE's session history, so you can open the conversation behind the answers. Questions on one version run one at a time.
(Claude Code lists no `claude -p` session by default; Ask records the entrypoint `agentledger-ask` instead.
`AGENTLEDGER_ASK_ENTRYPOINT=sdk-cli` hides them again.)
### Sharing
**One report, to someone who should ask their own AI about it:**
```sh
agentledger share repo/topic # → repo-topic.agentledger.zip: every version, sub-reports, traces, threads
# they run, on their machine:
agentledger open repo-topic.agentledger.zip # unpacks to ~/.cache/agentledger/shared/…, opens it; Comment and Ask work
agentledger link repo/topic ~/code/repo # to reproduce: their checkout of the code, at the commit open prints
agentledger --store <printed path> comments export repo/topic -o feedback.csv # or Export CSV in the page
# back on your machine:
agentledger comments import feedback.csv # their questions and their agent's answers join your threads
```
The file holds only that report: not the rest of your store, your local cache or your GitHub settings
(`--no-traces` and `--no-comments` leave those out too). When you share a newer version, they open the new file and
keep their own comments. On their side every page is sanitised, and their agent works in the unpacked folder: it
reads, and runs programs only inside its sandbox (see [Asking](#asking)).
**No credentials travel.** Before zipping, `share` passes every file (report, data, traces, threads) through the same
redaction as `trace prepare`: the values of secrets known on your machine (`.env` files near the store, the checkouts
and sessions behind the report, credential-named environment variables) and common key formats (API keys, GitHub and
cloud tokens, private keys, JWTs, passwords in URLs, `api_key=…` assignments) become `[REDACTED:<name>]`, your home
directory becomes `~`, and a raw Claude Code, Codex, Pi or Antigravity transcript is cut down to the conversation. Then the whole
bundle, built pages included, is scanned again and nothing is written if anything is left; a binary file that holds a
credential stops the share. Only the bundle changes, never your store, and `share` lists what it redacted, per file.
Traces still show the work itself (commands, file contents the agent read), so send them to people you trust.
**Reproducing it.** Each claim the report backs with a trace links to the lines it rests on, in the page and in
`agentledger trace show <report> 'trace:run.log#L24'`, so whoever reproduces it compares result by result, and their
agent is told which lines each claim cites.
Raw traces too large or too private for the store can stay in a **trace store**: TrajFS experiment batches published
as GitHub releases (one release per batch: `batch.json`, a `capture.json` per run with every file's SHA256, the
run's TrajFS store in parts). `publish --trace-batch <release link>` records the batch's runs and file lists on the
version, never the traces, and a citation names a file by its run's path and its path in the run:
`trace:exp-a/runs/r1/sessions/<id>/session.v3.jsonl#L2559`. Clicking it shows the batch, run, file and
SHA256; `agentledger trace get <report> '<ref>'` downloads only that run with the reader's own GitHub access, checks
every asset and the file against the capture, restores it with TrajFS (`traj`, or `--raw-root` with an original
copy) and keeps it in the store's `.cache`, where the page, `trace show` and Ask read it. The cited lines of a
trace-store file are never written into a page, and `serve --share` never serves `.cache` to other machines. `open` prints the repository and commit the report describes, with the `git clone`, `checkout`
and `link` commands; after `link`, their agent reads that checkout and can re-run the analysis there, in its
sandbox. Publish from inside the repository the report is about, so the commit is recorded.
**Everything else:**
- **Same network:** `agentledger serve --share` lets teammates read and comment at `http://<your-ip>:8765`.
- **Remote machine:** `ssh -L 8765:localhost:8765 <host>`, then open `http://localhost:8765` (Ask works through the tunnel).
- **Through GitHub:** teammates clone the private store and run `agentledger open`; everyone presses **Sync** in the
page (or runs `agentledger sync`) to send their comments and get the others'. Pages opened from disk can also **Save to GitHub** with a fine-grained token (Contents: read and
write), or **Export CSV** for `agentledger comments import`.
### Hosted shared comments
A static page keeps drafts in each browser until saved. A hosted review server can use
[github-sync.mjs](agentledger/assets/github-sync.mjs) to mirror shared comments into the private store's `comments.csv`.
Keep the GitHub token on the server, scoped to that store; reviewers need no GitHub token.
Apply [hosted-comments.sql](agentledger/assets/hosted-comments.sql) as a database migration, authenticate reviewers in
the host, persist their rows, then call `syncHostedComments(db, github, reportId)`. Pending rows survive a GitHub outage.
The adapter retries concurrent writes and does not commit unchanged rows. Only shared threads and agent replies to
them return to the page; unrelated private threads stay private. Agents review through the normal `agentledger sync` loop.
### Privacy and security
- Nothing goes anywhere but your own repo. Pages load no external scripts, fonts or images. The only network call a
page makes is Save to GitHub; Ask runs your own agent CLI, which sends what it reads to its model provider as usual.
- Ask reads, and runs programs only inside the agent's sandbox (no network, no writes outside a scratch folder,
credentials unreadable; read-only where no sandbox is available). It is only served to requests from the machine
itself; `--share` exposes reading and commenting, never Ask. Shared mode accepts IP addresses and this
machine's names only, which blocks DNS rebinding.
- Traces are shared with everyone who can read the store, and with whoever you `share` a report to (`share`
redacts credentials from everything it packs, see [Sharing](#sharing)). `--trace auto` shares a reviewed, redacted
copy of the session. `--trace <path>` attaches the file as it is: it may hold secrets
or personal data (publish warns when it spots a credential, and `agentledger trace check <file>` looks for them),
so the choice is yours. Once a store is pushed, deleting a trace leaves it in the git history: rotate any secret
that got in.
- Report HTML passes an allow-list sanitiser (no scripts, handlers, frames, forms or `javascript:` URLs); `--allow-scripts`
skips it for reports you fully trust.
- Don't publish a store through githack or GitHub Pages: both make the files public.
## Reference
| Command | |
|---|---|
| `agentledger` | Where your store is, what is waiting on you, what to run next |
| `setup [path] [--agent …]` | One-time setup: link or create the store; install the skill for Claude Code, Codex, Pi and Antigravity |
| `open [report-id \| file.agentledger.zip]` | Serve on this machine and open the dashboard, a report, or a shared report (`--share`, `--ask`, `--port`, `--into`) |
| `demo` | Build a sample store and open it (`--ask claude\|codex\|pi\|antigravity` to try a real agent) |
| `publish <id> <file\|folder>` | New report or new version (`--link-session auto\|PATH\|ID` required; `--trace auto\|PATH --summary --about --changes --resolves --asset --tag`) |
| `trace prepare <id> --link-session …` / `review <id>` / `approve <id>` | Write the redacted copy of a session that `publish --trace auto` shares, have an agent review it (`--agent claude\|codex\|pi\|antigravity`), and approve it |
| `trace check <file>…` | Look for secrets and credentials in files (exit 1 if any) |
| `sync [-m msg]` | Pull, rebuild, commit and push the store |
| `ask <comment-id>` | Have the agent answer a thread (`--backend`, `--cmd`, `--print-prompt`) |
| `comments list [id]` | Threads for agents (`--status open\|waiting\|closed\|all`, `--format md\|json\|csv`) |
| `comments reply / add / resolve / reopen / wontfix` | Work threads from the CLI |
| `comments import <csv\|->` / `export` | Move threads between browser and store |
| `share <report-id> [-o file]` | Pack one report into a file someone else opens with `agentledger open <file>` (`--no-traces`, `--no-comments`) |
| `link <report-id> <repo>` | Tell Ask where the code a report describes is checked out on this machine |
| `serve` | Like `open` without opening a browser |
| `tree`, `check`, `root` | List reports, validate the layout, print the store path |
| `draft <id> [-o file]` | Copy the latest source to edit |
| `template`, `set`, `project`, `path`, `build`, `init` | Skeleton, metadata, paths, rebuild, new empty store |
The store is `--store`, else `$AGENTLEDGER_STORE`, else the nearest `agentledger.json` above the current directory,
else the one `setup` remembered (`~/.config/agentledger/config.json`).
<details><summary>Comment CSV schema</summary>
One schema everywhere (browser export, `comments.csv`, CLI). Rows merge by `id`, newest `updated` wins; deletions are
tombstones.
| Column | |
|---|---|
| `id`, `reply_to` | thread or reply id; replies point at their thread |
| `report`, `version`, `module` | where it was opened |
| `kind` | question, issue, suggestion, note, praise |
| `quote`, `prefix`, `suffix` | the selected text and 40 characters either side, used to re-anchor it in later versions |
| `body`, `author`, `role` | the message; `role` is `human` or `agent` |
| `status`, `resolved_in` | `open`, `resolved`, `wontfix` or `deleted`; the version that resolved it |
| `created`, `updated` | ISO 8601 UTC |
</details>
## Development
```sh
git clone https://github.com/SecretSettler/AgentLedger && cd AgentLedger
pip install -e .
python -m unittest discover -s tests -v
agentledger demo
```
The CLI is plain Python with no dependencies; the pages are plain CSS and JS in `agentledger/assets/`, inlined into
every generated page, with no build step. `claude plugin validate .` checks the plugin manifests.
Apache-2.0.
© SecretSettler · Apache-2.0 · SecretSettler/AgentLedger