Clawdeck

An unofficial local dashboard for Claude Code. Point it at any project you
work on with Claude Code and it shows what is actually happening: live
sessions, an event timeline, cost and context telemetry, git worktrees,
reviews, and delivery state - in one local web UI.

Feature tour

Git + Claude Workbench (Delivery hub) - what stands between this branch
and a shipped change, connected to the code and to Claude.

• Readiness answers two questions separately, because they are different
  questions: can the REMOTE change merge, and has all the LOCAL work reached
  it. A dirty worktree blocks the second and not the first. Each axis is
  READY | BLOCKED | UNKNOWN, and UNKNOWN is a real answer - "I cannot show
  that you can merge" is not "you can merge".
• Review Inbox imports the PR/MR discussion read-only, maps each comment to
  the line it now points at (anchor-aware, so a line that moved by eight reads
  as moved, not changed), and derives a state with its evidence attached. Fact,
  derivation and model output are three different visual grammars; every derived
  state has a Why? that shows the reasons verbatim.
• CI is read for the commit the change is on, never for "the latest run",
  and covers every check context - a green Actions run beside a failing
  external status is failing, and an incomplete read is unknown, never a
  pass. Failing jobs offer their output (tail only, secret-scanned) and a
  scoped Fix locally task.
• Attention is what needs a person, kept apart from what blocks delivery:
  an unpushed commit blocks shipping and needs nobody's judgement, so it never
  reaches the badge.
• Decision ledger records why the change went the way it did. Claude can
  draft; only a person can decide, and the record says which.

Clawdeck never writes to the forge. There is no reply, resolve, approve or
merge action, no mutation document in the provider layer, and model output can
never move state - only a human action promotes advice into anything.

Trace waterfall - every turn of a session broken into tool-call spans
with real durations: subagent tasks, failing commands, and human-wait spans
(dashed, width-capped) at a glance.

Burn rate & forecast - $/hour from statusline cost deltas, 5h/7d
depletion slopes with ETA, per-model token history over 7d/30d/all-time
windows. Estimates are labelled as estimates; unknowns stay unknown.

Ask Clawdeck (Prompt hub) - ask questions about panel state, answered by
a local claude -p child running tool-less in a sterile temp dir; the only
context sent is a compact, secret-scanned snapshot summary.

Also in the box:

• Config map (Configuration) - every rule, slash command, skill, agent,
  MCP server, and hook the checkout declares to Claude Code, overlaid with
  what recent sessions actually invoked. Dead config shows up dim.
• MCP & skills analytics (Cost) - per-server call counts, error rates,
  and durations from recent transcripts: evidence for whether a server earns
  its context cost.
• Host vitals (Health) - CPU, memory, and checkout-volume disk next to
  the panel's own self-performance numbers.
• Cheap refreshes - snapshots carry per-section content hashes, so
  unchanged views skip re-rendering, /api/snapshot answers 304, and the
  page revalidates when you come back to the tab.

Principles:

• Zero dependencies. Pure Node stdlib on the server, browser-native ES
  modules in the UI. No build step, no node_modules.
• Loopback-only. Binds 127.0.0.1, refuses foreign Host headers, gates
  privileged routes behind a per-launch bearer token.
• Degrades gracefully. Everything works read-only on a bare git repo; more
  signal appears as you opt in to the hooks, statusline bridge, and OTEL.

Clawdeck is a community project. It is not affiliated with or endorsed by
Anthropic.

Quickstart

npx clawdeck-panel run --checkout /path/to/your/project

Or from a clone:

git clone https://github.com/m-sanchez/clawdeck.git
cd clawdeck
node scripts/panel-run.mjs --checkout /path/to/your/project

That alone gives you the git-level views (worktrees, diff, commits, MR draft)
and session liveness from Claude Code's own transcript files — zero setup,
nothing written to your project, one loopback server that stops when you
close it.

npx vs a clone for init. The one-off run above is fine over
npx. But init (below) writes generated /panel slash commands that
reference the panel's install path — under npx that is the npm cache
directory, which npm may garbage-collect. If you plan to keep the
integration installed, run init from a clone (or a global install) so
the referenced path is stable.

Install the integration (optional, recommended)

The event timeline, activity feed, and cost views are fed by a tiny hook +
statusline bridge you install into the observed project:

npx clawdeck-panel init --target /path/to/your/project --statusline

init copies the emitter hook (and its lib) into the project's
.claude/hooks/, installs /panel slash commands, and prints the hook
registrations to paste into .claude/settings.json - or merges them for you
with --write-settings (only ever appends its own entries; backs up first).
Restart your Claude Code session afterwards.

What you get at each level

To point Claude Code's OTEL exporter at the panel, set these before
launching Claude (the panel prints its port and token on start; the
/v1/metrics endpoint requires the panel token):

export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=http/json
export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:<panel-port>
export OTEL_EXPORTER_OTLP_HEADERS=x-panel-token=<panel-token>

Forge connectors

Clawdeck auto-detects the project's git host from origin and speaks to it
read-only:

• GitHub (github.com + GHES) - PRs, review threads, and checks.
  GITHUB_TOKEN optional for reading a public repo's status; needed for review
  resolution and job logs. If the gh CLI is signed in, Clawdeck uses that
  credential rather than asking you to configure a second one
  (CLAWDECK_NO_GH_CLI=1 turns that off).
• GitLab (gitlab.com + self-hosted) - MRs and pipelines. Needs
  GITLAB_TOKEN.
• Bitbucket Cloud - PRs and Pipelines. Needs BITBUCKET_TOKEN (a
  repository/workspace access token).
• Azure DevOps - PRs and builds. Needs AZURE_DEVOPS_TOKEN (a PAT).
• Gitea / Forgejo - PRs and commit status. Self-hosted hosts are
  anonymous, so opt in with GITEA_URL (+ GITEA_TOKEN for private repos).

Tokens live in the observed project's .claude/settings.local.json (or env),
or come from the signed-in gh CLI for GitHub, and never reach the browser.

Roadmap

• Session → subagent hierarchy tree view.

Architecture

Claude Code hooks ──► durable spool (at-least-once) ──► single-writer store
                                                            │
statusline bridge ──► per-session telemetry records ────────┤
OTLP-JSON exporter ─► OTEL receiver ────────────────────────┤
                                                            ▼
                                             HTTP + SSE server (loopback)
                                                            ▼
                                             browser SPA (no build step)

The server never watches the filesystem; it polls adapters per request and on
a bounded SSE interval. See ARCHITECTURE.md and
docs/DECISIONS.md.

Security model

• Loopback bind + strict Host allowlist (anti-DNS-rebinding).
• Per-launch bearer token, delivered to the browser only in the URL
  fragment (never in served HTML, API bodies, logs, or Referers).
• Separate per-launch ingest token for the event POST route.
• PID+nonce ownership checks so lifecycle scripts can never kill a reused PID.
• Single-writer lock on the canonical event store; a second panel degrades to
  its own local store instead of corrupting the shared one.
• Deep links to Claude are fail-closed secret-scanned: a prompt containing
  suspected secret material refuses to become a URL.
• The Workbench is read-only against every forge. REST calls are GETs, the
  one GraphQL POST carries a frozen read-only query document, and no
  reply/resolve/approve/merge action exists to be called.
• A task brief goes to a file, never a URL. The deep link carries only the
  task id, that path and a correlation marker, so review text and diffs never
  enter browser or OS history.
• CI job output is fetched per job, tail-bounded and secret-scanned in both
  directions: a hit withholds the text, and a scanner that will not load
  withholds it too.
• No shell endpoint. Commands are a fixed allowlist with server-built argv.

Details: docs/SECURITY.md.

Development

npm test              # node --test
npm run self-test     # boots the server against this repo and checks /health

License

MIT