Caprock

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 会话登录 社区 / 第三方 ClaudeCursorVS CodeWindsurf
查看接入方式

Caprock 的只读本地 MCP 服务器。Caprock 是一款用于记录编码代理会话的桌面应用。它允许 Claude Code、Codex 或任何 MCP 客户端搜索 Second Brain 记忆和过往会话,并读取成本和 CI 状态。安装:claude mcp add caprock --...

一句话选型结论

按资料字段整理

Caprock 属于文档知识类 MCP 服务器,stdio · 本地进程,会话登录,可直接接入 Claude、Cursor、VS Code 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式stdio · 本地进程 鉴权会话登录 部署方式本地部署
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 会话登录
客户端在本机拉起子进程,数据不出本机
pipx uninstall caprock || pip uninstall -y caprock # whichever you used rm -rf ~/.caprock # its old data which caprock # should now print nothing

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好会话登录对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Caprock当前 未标注 stdio · 本地进程 本地部署 有 2026-11-20
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式会话登录远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-11-20上游最后核验时间

详细介绍

49.1 KB
来自项目仓库与上游目录的原文,未做删改

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 /clear or 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 mcp lets 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 {&quot;status&quot;:&quot;ok&quot;}. 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 &quot;Add a /healthz endpoint&quot; \ --done-criteria &quot;go test ./...&quot; --done-criteria &quot;go vet ./...&quot; --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

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
Caprock 怎么安装?

在客户端按下面的安装命令接入:pipx uninstall caprock || pip uninstall -y caprock # whichever you used rm -rf ~/.caprock # its old data which caprock # should now print nothing。装完在客户端配置里引用同一个包或端点。

Caprock 怎么在 Claude、Cursor、VS Code 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Caprock 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Caprock 需要 API Key 吗?

资料标注需要会话登录认证,使用前准备好对应凭据,并按最小权限配置。

Caprock 支持哪些客户端?

资料标注支持 Claude、Cursor、VS Code、Windsurf、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Caprock 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

Caprock 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Caprock 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-11-20。