Caprock
See every coding agent you run, wherever it runs: who is waiting on you, who is stuck, how close the limit is, and every pull request to release with what it cost.
Caprock is a free, open-source (Apache-2.0) desktop app for macOS, Windows and Linux that runs and tracks every
Claude Code, Codex, OpenCode and Gemini CLI session on your machine in one place: agents side by side in tabs,
spend per repo against your plan limits, a searchable history of every session, and your agents from your phone.
Nothing leaves your machine: no account, no telemetry.```bash
brew install --cask dspv/tap/caprock-app
A real Caprock work session in this repository, replayed on a demo stand. Example figures.
Other downloads: macOS .dmg ·
Windows ·
.AppImage ·
.deb ·
.rpm ·
the daemon on its own
```text
I want to contribute to Caprock. Run `gh repo fork dspv/caprock --clone`,
then read docs/contributing-with-ai.md in the clone and follow the prompt
under "The prompt" in it, step by step. Work on the smallest open issue
labelled "good first issue" unless I name another, and tell me which.
Paste it into Claude Code, Codex or any coding agent, in an empty folder. It
runs every check on your machine and opens the pull request;
how it works.
Every pull request, from agent to release
The Pipeline shows the repository's pull requests with every check per job and OS,
how long they took and what the agents spent on them. A red run, a conflict or
a branch behind master gets Fix CI with agent, Fix conflict with agent or
Update branch from the pull request, or from its row beside the agent; the Changes view stages, commits and pushes
without leaving the window.
Nothing waits on you unseen
Sessions stuck on a permission prompt come first. For the ones Caprock
started, answer Yes or No from the card, a notification, the menu bar or
your phone. A notification carries Approve only when it shows the whole
request, so you never answer a command you have not read.
Every agent in a real terminal tab
Claude Code, Codex, OpenCode and Gemini CLI in tabs and split panes, per
project and per git worktree, with a shell beside them. The sessions you start
in your own terminal show up too. Keep a work and a personal Claude Code or
Codex account side by side and pick which one each new session runs on; three
per agent are free.
What each repository costs, and how close the limit is
Every turn priced at API list prices, per repository and per service in a
monorepo — an estimate of what the same work would cost through the API, not a
bill. Your Claude and Codex plan windows sit beside it, with a warning before
you hit the limit.
And the rest
- Your history, kept. Every session stays searchable after Claude Code's
30-day cleanup deletes the transcript — including what the agent wrote. - Runaway agents caught. Loop alerts on repeated tool calls, and an opt-in
task runner for Claude Code that calls a task done only when your own test
commands pass. - One card after
/clear. A/clearor a fork starts a new session id;
Caprock links it to the one before, so the conversation stays one card with
its earlier parts a click away. Claude itself starts that part with an empty
context (details). - Bring your Obsidian notes. Import a vault into Second Brain without
changing its files. Links and tags join the graph; letting agents use the
notes is a separate choice, off by default (guide). - Your agents can ask it.
caprock mcplets Claude Code, Codex or any MCP
client read Second Brain, past sessions and what they wrote, cost and CI —
read-only; for Claude Code it is also a plugin
(details). - On your phone, from anywhere. Pair once with a QR code; an encrypted
relay carries only ciphertext (details). - Local. One SQLite file on your disk, loopback only. No account, no cloud,
no telemetry.
In August the author ran $5,898 of Claude Code on a $200 Max plan — 29× at
API list prices, and
found out only because Caprock counted it.
Install
Caprock is a desktop app; under it runs a local daemon that also serves a
browser dashboard, and the app bundles it.
The desktop app — macOS first, with Windows and Linux builds:```bash
brew install --cask dspv/tap/caprock-app # macOS (universal)
Or download the newest build directly: macOS .dmg,
Windows installer, Linux
.AppImage, .deb or
.rpm — every version is on
Releases. The Mac app
is signed with a Developer ID and notarized; the Windows installer is not
code-signed yet, and docs/install-app.md has
SmartScreen's one-time "Run anyway". What is in the window, the shortcuts and the phone:
docs/app.md.
**Or the daemon and its browser dashboard** on their own:```bash
# macOS / Linux
brew install dspv/tap/caprock
# Windows
scoop bucket add dspv https://github.com/dspv/scoop-bucket
scoop install caprock
# winget too, once Microsoft has merged the manifest for a release:
# winget install dspv.caprock
caprock up # opens localhost:22776; offers to set up hooks + plan-limit status line
Have Go? go install github.com/dspv/caprock/cmd/caprock@latest — the dashboard
is embedded, so it works with no Node build. No package manager? Grab a binary
from Releases.
Or let your coding agent install it — paste one short prompt as a new message.
The agent runs the same install script as the button on
caprock.dev and leaves Claude Code's settings alone: the
app asks you itself whether to connect it. What the script does, where things
live and how to remove them is in docs/install-agent.md,
on master, beside the code it describes. Judged by
five fresh agents with no other context (2026-10-16, two Sonnet, two Haiku, one
Opus; none ran anything): four would go ahead and one would ask first, all
rating it 1–2 of 10 for looking like an injection, as the longer prompt it
replaces did. Each said it would read the script before running it, which the
prompt invites.```text
Install the Caprock desktop app for me. It is open source (Apache-2.0), a local
app for my Claude Code sessions: https://github.com/dspv/caprock
What the install does and how to remove it:
https://github.com/dspv/caprock/blob/master/docs/install-agent.md
I'm on macOS, so it's curl -fsSL https://caprock.dev/mac.sh | sh — read the
script before you run it if you like. Leave my Claude Code settings alone; the
app asks me itself. Tell me when it's open.
On Windows the command is `irm https://caprock.dev/win.ps1 | iex`, on Linux
`curl -fsSL https://caprock.dev/linux.sh | sh`.
Coming from the old Python caprock? Remove it first.
There was an earlier, unrelated Caprock on PyPI — a command-line stats tool that
read Claude Code usage from a proxy. This one is a Go binary with a dashboard and
shares nothing with it: different data, different install, same name. Remove the
old one so the two `caprock` commands don't shadow each other:```bash
pipx uninstall caprock || pip uninstall -y caprock # whichever you used
rm -rf ~/.caprock # its old data
which caprock # should now print nothing
Then install as above. Nothing is lost: this version reads the transcripts
Claude Code already writes, so your whole history appears on first run — no
migration, no import. (Only ~/.caprock/savings.jsonl from the old tool is
dropped; copy it elsewhere first if you want to keep those numbers.)
On first run caprock up asks before adding its hook and status-line entries to
~/.claude/settings.json (it backs the file up and never touches your other
settings). Say no and it still reads your history from transcripts.
Run OpenCode,
Codex,
DeepSeek Harness,
Hermes Agent,
Cursor or
Gemini CLI too? All are shown on
the same screens — OpenCode, Hermes Agent and Cursor from their own databases, Codex
and DeepSeek Harness from the transcripts they write, Gemini through the
telemetry it writes when Caprock starts it. See
OpenCode, Codex and DeepSeek Harness and
Hermes Agent and Cursor for what that covers and what it does not.
Caprock starts Codex, OpenCode (1 or 2, whichever opencode --version
says is installed), Gemini CLI, Hermes Agent and Cursor's cursor-agent sessions too: whichever of them
is installed appears next to Claude Code in the New Session dialog — same
terminal, same directory picker, its own filter chip — and the dialog remembers
the one you picked last. A Codex or OpenCode session started here shows its
cost and answers on the same page as its terminal, and one that has ended can
be continued with "continue here". "Continue in…" on any session starts a new
one in the agent of your choice with a summary you read first — what the agent
last said, what changed in the folder, the PRs it opened. For Gemini, install
the CLI
(npm install -g @google/gemini-cli).
With a Gemini key set (see Premium for where), Caprock passes it to
the child process. Gemini has no hooks, and the session history it keeps
for itself is not something Caprock reads; it does write OpenTelemetry, and
Caprock asks it to write that to a file it then reads
(GEMINI_TELEMETRY_OUTFILE);
what you ask it is kept there too, so the Memory screen can find a Gemini
session by your question. Starting and watching Gemini sessions is free, like
every other agent.
The desktop app
The app opens on your terminals, not on charts. The sidebar starts with
today's spend and what is running and waiting; each project in it opens to
its agent sessions and shells, with a dot for what every session is doing,
and whatever is waiting on you sits at the top.
⌘T opens a shell, ⇧⌘N an agent, ⌘O adds, creates or clones a project. Tabs
come back when you reopen it. Closing an agent's tab ends it if it is idle,
its conversation kept, and asks first if it is working. An agent's tab switches between its terminal
and a chat view of the same conversation.
Outside the window: the menu bar shows your plan limits, today's spend and
the sessions waiting for approval; the Dock badge counts them; ⌃⌥⌘C brings
the window up from anywhere. When an agent stops on a permission prompt, a
macOS notification carries Approve and Deny — Approve only when the
notification shows the whole request, so you never answer a command you have
not read. Every dashboard screen below is inside it too.
The whole tour is in docs/app.md. Voice mode says "No audio
detected from microphone"? See
Voice mode and the microphone.
Your numbers, ready to publish
caprock report prints what your captured usage comes to at API list prices,
in a form you can paste somewhere. When the total includes Codex, Gemini or
DeepSeek turns, the caveat names every vendor whose list was used and the
headline stops calling it all Claude Code:```bash
caprock report # a block for a post
caprock report --markdown # the same facts as a table
caprock report --json # machine-readable
``````
$9,704 of Claude Code at API list prices on a $200/month plan — 41.6× the fee.
Priced from captured tokens at Anthropic list prices — what the same work would
have cost through the API. Not a bill, not a discount received, and not money
back: without the plan I would not have run this much.
2026-07-19 → 2026-08-22 · 33 active days
paid $233.33 over that window · same usage at API list $9,704
59,578 turns · 57 sessions · 26 projects
99% cache hit · 89% of input cost cut by cache
15,701,665,082 tokens read from cache · 128,597 fresh input
The caveat is part of the output, on every shape, because the number is not a
bill and not money saved — it is what the same work would have cost through the
API, and it is quotable enough to be worth making hard to quote without that.
The multiple compares your usage against the plan fee **for the window that was
measured**, so the report also prints the fee it divided by, with cents, so the
division checks out on sight. The raw token counts sit under the cache
percentages: they are what those percentages are computed from, and they are the
half of the cache story a reader can picture. Set your plan in
the dashboard header first; with no plan stated, `caprock report` says so and
shows no multiple rather than guessing one.
It reads from the running daemon and only issues GETs. Numbers move as you work,
so re-running it is the point — a figure you pasted last month is a figure about
last month.
## Is it Caprock?
`caprock doctor` prints what Caprock itself costs your machine — memory and
CPU of the daemon, the app and its window, and the terminal holders; the data
directory on disk; the daemon's own disk reads and writes — and flags a second
daemon, a second app, orphaned terminals and an oversized database. It works
with no daemon running and exits 1 when something is flagged. Orphaned idle
terminals and an oversized write-ahead log are cleaned up on their own, and the
report says when. Details: docs/doctor.md.
## Take the record out
Every agent Caprock reads — Claude Code, Codex, OpenCode, Gemini CLI, DeepSeek, Hermes, Cursor —
lands in the same tables with the same columns. `caprock export` writes one of
them out, for a spreadsheet, a notebook or your own warehouse:```bash
caprock export --since 30d > events.tsv # one row per turn and tool call
caprock export sessions --format csv --out s.csv # one row per session
caprock export --agent codex --format jsonl # one agent, as JSON lines
It reads the database read-only, so it works with the daemon stopped. The
columns, what each agent's source maps to, and what is deliberately left out are
in docs/schema.md. The record also outlives the agents' own:
Claude Code removes its transcripts after 30 days by default, and Caprock
keeps what it read from them.
A session you do not want counted — a test run, say — comes out with Remove
from Caprock on its page, or in bulk from the terminal. It lists first and
removes only with --yes; a removed session is never read back in:```bash
caprock sessions rm --cwd-prefix /private/tmp/scratch # what would go, and its cost
caprock sessions rm --cwd-prefix /private/tmp/scratch --yes # remove them
## Ask Caprock from your agents
`caprock mcp` is a read-only MCP server, so
the agent you are working with can look things up instead of you pasting them:
"did we decide this before?", "which session explained the SSO change?", "what
has this repository cost this week?", "is CI green?".
It is also a **Claude Code plugin**, from the plugin marketplace in this
repository:```bash
claude plugin marketplace add dspv/caprock
claude plugin install caprock@caprock
Or add the server yourself:```bash
claude mcp add caprock -- caprock mcp # Claude Code
codex mcp add caprock -- caprock mcp # Codex
It reads the running Caprock over loopback and opens no port; no tool can type
into a session, start or stop one, or change a setting. The tools, what each
returns and what is redacted are in `docs/mcp.md`; Settings →
*Use Caprock from your agents* has the commands with a copy button.
## What it is
Claude Code runs in a terminal. Caprock is the app that terminal lives in,
and the window into what it does. One local daemon, with an app and a browser
dashboard on top. Your data never leaves your machine.
**What that database holds.** Everything Claude Code read and wrote: your
prompts, its replies, and the full output of every tool call. That output is
where secrets end up — an API key printed by a command, a token in a `.env`
file that got read. The file is `0600` and nothing sends it anywhere, but it
is inside your backups, so treat it as you would your shell history: do not
put it in a bug report, and do not hand it to anyone debugging an issue for
you. `caprock down` and deleting the data directory removes all of it.
## What your context is costing you
Every call re-sends the whole conversation before it does anything. You pay for
that on every call, and it grows as the session does — so the 300th call in a
long session costs real money before it has run.
Caprock puts the price where you are already looking. A running session says
what its **next call** costs at the context it is carrying. The lifetime
breakdown says what that has come to. On the machine this was recorded on, it
is 79% of the bill.
The number is exact, not modelled: the context of every call comes from the
token counts Claude Code itself records, priced per model from the pricing
table. Calls that arrive without a way to attach them to the turn that paid for
them are excluded and counted, so a figure is never quietly short.
## OpenCode, Codex and DeepSeek Harness
Caprock also reads OpenCode,
Codex and
DeepSeek Harness sessions, on
the same screens as Claude Code. A machine that runs more than one has its spend
split across tools that each see part of it; here the projects list, the history
and the cost add up over all of them, and the rows carry each agent's own mark
so you can still tell them apart.
**Or see one at a time.** The Home screen carries
`all / claude / opencode / gemini / codex / deepseek / hermes / cursor` in the middle of its
header, and it applies to the whole screen — today's totals, the live pulse, the
activity feed, the projects list and the session cards all answer the same
question. It appears only on a machine that runs more than one.
Nothing to configure for any of them. OpenCode is found through its own
database, opened read-only — OpenCode 1 and OpenCode 2 alike, including a
database OpenCode 2 migrated from 1, where each session is counted once; Codex through the transcript it writes per session,
under `$CODEX_HOME` (or `~/.codex`), archived sessions included; DeepSeek
Harness through the transcript it writes per session. No shim, no
settings file to edit, and sessions from before you installed Caprock are
included, because each tool keeps its own history. What OpenCode, Codex and
DeepSeek Harness wrote back is searchable on the Memory screen beside Claude's.
**The cost works differently for each, and it matters.** OpenCode computes its
own figures and Caprock passes them through, so they match what OpenCode
reports. Codex reports how many tokens a turn used but never what it cost, so
those are priced from Caprock's own table of OpenAI list prices. Like every
number here, both are modelled from list prices, not a bill.
Three things about Codex figures worth knowing:
- A turn whose transcript does not name the model it ran on keeps its tokens and
shows **no cost**, rather than a guessed one. `caprock status` reports how many.
- About half of Codex's token reports give a total without breaking it down by
kind. Caprock counts that total as input, which is the unqualified rate — so
for those turns the cost is an **upper bound**: any part of it that was really
a cached read cost a tenth or less of what is shown.
- OpenAI bills the gpt-6 models for writing to their cache, at 1.25x input, but
Codex does not report how many tokens were written. Those arrive as plain
input, so a gpt-6 figure can be low by up to a quarter of that unreported
share.
**Codex's plan limits** sit on the Cost screen under Claude Code's, labelled as
Codex's: the 5-hour and weekly windows as Codex last wrote them into a session
transcript, with the time it wrote them. Which windows appear depends on the
plan — some ChatGPT plans have no 5-hour window. They are shown as measured and
never forecast.
**What is not there yet.** Caprock starts, types into and stops the Codex and
OpenCode sessions it started, in terminal tabs; DeepSeek Harness is read only,
and the task runner works with Claude Code alone. A session started outside
Caprock refreshes every few seconds rather than instantly, so the Home screen
lags a little behind it — the Cost and Lifetime screens are unaffected. Verified on macOS; it builds and its tests pass on Linux and
Windows, but it has not been run on either.
### Hermes Agent
Caprock reads Hermes Agent's
own database (`~/.hermes/state.db`), read-only, and starts Hermes in a
terminal tab from **New agent**. Every Hermes session — its CLI and TUI, and
the cron jobs and gateway chats that run with nobody watching — is on the same
screens, with Hermes's own cost figures, never re-priced: the Cost screen says
which part the provider reported and which part is Hermes's estimate, and
shows background runs apart, by source. Delegated subagents sit inside the
session that delegated them, counted once. Nothing is installed into Hermes.
Only Hermes's default profile is read. See docs/hermes.md.
### Cursor
Caprock reads Cursor's Agent and Composer chats from the
editor's own database, read-only, with the cost Cursor itself recorded for
each chat and model; a chat Cursor recorded no cost for shows its tokens and
no price. It starts and continues `cursor-agent` from **New agent**, with the
model you type, and sees `cursor-agent` chats once you turn on Cursor's hooks
on the Cost screen — merged into `~/.cursor/hooks.json` beside anything
already there, and removable. The Cost screen also estimates how many tokens
Cursor sends on each request beyond what you typed, per model, beside Claude
Code's figure for the same model. See docs/cursor.md.
### Claude Code on DeepSeek
Caprock can also start Claude Code itself on DeepSeek's models, on your own
DeepSeek API key — free. Paste the key in Settings → *Subscriptions*, under
Claude Code; *New agent* and *Quick chat* then offer **DeepSeek · your API
key** in their *Subscription* picker. A session started on it runs in your
usual Claude Code setup, with DeepSeek's
documented variables
and your key set for that one process, so its model calls go to
`api.deepseek.com` instead of Anthropic and DeepSeek bills your key; your
claude.ai sign-in is not used and its plan limits do not apply.
- **What leaves the machine.** The session sends DeepSeek what Claude Code
would otherwise send Anthropic: your prompts, the files it reads and tool
output. Caprock itself sends nothing, and the key goes into that session's
environment only — never its command line, the database or a log. *Remove
key* in Settings takes it away for every new session.
- **What you see.** The session's card says *DeepSeek*, its model is
DeepSeek's, and its cost is priced at DeepSeek Flash's off-peak list price
(DeepSeek bills double in its weekday peak hours, so those turns read low).
It is never counted against your Claude plan's 5-hour or weekly window.
- **Model.** Every session runs on DeepSeek Flash; the launcher's Claude
model choice does not apply to it.
- **Not yet verified** against a funded DeepSeek account: the endpoint, the
key and Claude Code's routing were checked live, but the model name
DeepSeek reports back has not been seen, so if it is not `deepseek-flash`
those turns show as unpriced rather than mispriced.
## Why
- **See it** — live activity, tokens, cost, and loop alerts per session, plus
what each repository costs you and who is working in it.
- **Find what Claude said** — the reasoning and the "here's what changed, here's
what I still need from you" that otherwise lives only in terminal scrollback,
searchable across every session.
- **Keep what matters** — Second Brain: drop an answer, or a line of your own,
into a graph of ideas, decisions and findings, each linked to its project,
its topics and the moment in the session it came from — or let your own
`claude` build it from finished sessions, once you say yes. Free.
Kept on this machine.
- **Pick up where you left off** — a new session in a folder you have worked in
is handed the last thing the previous one said there (on by default, off in
settings). You can measure whether that helps: an opt-in setting holds it back
from one new session in four and the Memory screen compares the two.
- **See what it went on** — not just which model or which repository, but what
the money was doing: running commands, writing code, reading and searching, or
turns that called no tool at all.
- **Know what it's worth** — your measured usage priced at the API rate, against
what your plan actually costs.
- **1-click terminal** — the Terminal button on a project opens the session
Caprock is running there, picks up one started elsewhere, or starts a new one.
A running card on Home opens in its terminal too. Session pages and projects
link to the repository and the pull requests a session opened.
- **Steer it** — spawn, pause, and kill sessions from the dashboard, and continue
one that has ended. Each card says what the session was about and when it was
worked in, says why when it cannot be continued, and ended sessions are
searchable. After a reboot the Home screen lists the sessions it interrupted,
each with continue.
- **Trust it** — an opt-in task runner whose tasks finish only when the checks
Caprock runs come back green.
- **Local-first** — loopback only, no servers, no telemetry, no account. Nothing
reaches the network unless you switch it on: the release check, the Gemini
chat on your own key, GitHub, and the weekly report, alerts and chat through
your own Telegram bot are each off by default. Caprock may ask you about
a feature it is considering; your answer reaches caprock.dev only if you
press Send, and the card says exactly what it sends. A bug report you write
in Caprock goes privately to Caprock support at caprock.dev, not GitHub,
only when you press Send to support, and the sheet lists what it sends.
What your usage is actually worth — the same work priced at the API rate,
against what your plan costs — is on the Cost screen, and everything you have
ever run through it on Lifetime: measured, not estimated.
## How it works
- **Observe** — watches every `claude` session via hooks + transcripts, and
draws the last hour as a pulse: bar height is how much happened that minute,
colour is what it cost.
- **Control** — run and drive sessions from the browser. When a session is
waiting on you, **what did it ask?** shows the last thing Claude said without
a trip to the terminal.
- **Orchestrate** — run queued tasks unattended, with a test gate; a task is done
only when green. Opt-in, off by default — see below.
Nothing to change in your workflow — it starts by watching the sessions you already run.
## Run tasks unattended (advanced, opt-in)
This is the one part of Caprock that starts sessions on its own, so it is off
unless you ask for it. Turn it on from the Tasks screen — the button creates the
queue directory and starts the board without restarting the daemon. The honest description is **an unattended task runner
with a test gate**: the closest thing you already know is a git worktree plus a
shell loop. What it adds is that a worker cannot stop early, a failing check
bounces back with its output attached, spend is attributed per task against a
budget, and there is a board showing where everything is.```bash
caprock up --hive ~/caprock-tasks --repo ~/dev/myproject
--hive is a queue directory; Caprock creates it, and seeds it with a README
showing the task format so it explains itself; the queue starts empty. --repo is the checkout the work
happens in (default: the current directory). Your own working tree is never
touched — each worker gets its own git worktree at
/.caprock-worktrees/, on a branch named
caprock/.```
~/caprock-tasks/
├── README.md # what this directory is
├── tasks/<id>.md # one file per task — the source of truth
├── agents/<id>/ # identity, memory, inbox/, outbox/
├── approvals/ # decisions waiting on you
├── verifications/ # captured output of every check that ran
└── ledger.jsonl # append-only log of every state change
A task is a markdown file with YAML front matter. This is a complete one:```yaml
---
id: t-healthz
title: Add a /healthz endpoint
status: inbox
assignee: null
budget_usd: 3
done_criteria:
- go test ./...
- go vet ./...
verify_rounds_used: 0
---
Add a GET /healthz returning 200 and {"status":"ok"}. Cover it with a test in
the existing handler test file.
Create one from the dashboard's Tasks screen, or from a terminal:bash
caprock task create --title "Add a /healthz endpoint" \
--done-criteria "go test ./..." --done-criteria "go vet ./..." --budget 3
caprock tasks # the board
caprock status # includes which hive is in force
Then press Start orchestrator on the Tasks screen. Nothing runs until you
do.
What done_criteria is
Plain shell commands. When a worker reports it has finished, Caprock runs
them — not the agent — in that worker's worktree, with a five-minute ceiling
each. Every command exits 0 and the task moves to done. Any command fails and
the output bounces straight back to the worker to try again; after three rounds
it stops and asks you. A task with no done_criteria cannot be verified, so it
is never marked done on a worker's say-so.
They run in a real checkout of your repository, so treat them as commands you
are running yourself: go build ./... will leave a binary behind exactly as it
would in your own tree.
Before you turn it on
- Workers run with permission prompts skipped (
--dangerously-skip-permissions),
in a worktree of your repo. A task body is acted on without a further
confirmation from you. Give each task a budget. - Only for independent tasks. Nothing here merges branches, and nothing
notices two workers editing the same file. Give concurrent tasks separate
ground. - You land the work. When a task is done, open its card: it shows the diff,
the checks that passed, the branch, and the git command that merges it. Caprock
never writes to your branches itself.
Found a bug, or something that did not explain itself? The feedback button
in the header opens a prefilled GitHub issue in your browser — nothing is sent
…(正文过长,页面只展示前面部分,完整内容见仓库)
