SigRank MCP

🏆 SigRank is live: signalaf.com — the leaderboard for how efficiently you use AI, not how much. Run npx sigrank to see your cascade now. Token counts only. Never your prompts.

Table of Contents

• The SigRank ecosystem
• Quickstart
• Install from GitHub
• Install via Smithery
• Commands
• MCP Server mode
• Cascade math
• Token Pillars
• Platform adapters
• Privacy
• Env vars
• Dev / test
• File map
• Contributing
• License

The board	Your operator profile
Every operator ranked by Υ Yield — the architecture of the cascade, not raw spend	Cascade layer, class, and fingerprint — derived from four token counts

Run sigrank enroll then sigrank submit to get ranked and claim your public profile at signalaf.com.

---

The SigRank ecosystem

Repo	What it is	Install
sigrank-mcp (this repo)	The instrument — extracts 4 token pillars, computes the cascade, submits to the leaderboard. MCP server + TUI dashboard.	npx sigrank
sigrank-app	The leaderboard — signalaf.com. Privacy-preserving operator profiles, class tiers, board rankings.	signalaf.com
signaf	The coach — reads your session logs, builds a taste profile, measures ASI, coaches you on token efficiency.	npx @burnmydays/signaf
sigrank-vscode	The IDE extension — see your cascade metrics inline in VS Code.	code --install-extension sigrank.sigrank
fundscore	The repo scorer — investor-readiness scoring for GitHub repos. CLI + MCP server.	npx fundscore

Also in the MO§ES™ suite

Site	What it is
SIGNOMY	Governed AI agent marketplace where ranked agents form teams, fill slots, run missions, and earn revenue under constitutional protocol. Agents are free. Operators pay.
MO§ES	The governance framework that underpins SigRank, SIGNOMY, and all governed agent operations. Structural accountability for agentic systems.

Quickstart — 3 steps to the board

# 1. Install (pulls ccusage + tokscale automatically — no separate installs)
npm install -g sigrank

# 2. Sign in (paste a connect code from signalaf.com → Settings → New key)
sigrank enroll

# 3. Submit your cascade to the board
sigrank submit

# (cautious? see exactly what would be sent — four counts + a signature — sending nothing)
sigrank submit --dry-run

That's it. sigrank reads your local AI session logs on-device, derives your token cascade (Υ Yield, Leverage, Velocity, 10xDEV), and publishes to signalaf.com. No paste, no transcript content — only the four token counts leave your machine.

Or just explore without signing in:

sigrank          # launches the full tabbed TUI (dashboard, compare, board, watch)
npx sigrank board --once    # print the live leaderboard once

Install from GitHub

git clone https://github.com/SunrisesIllNeverSee/sigrank-mcp.git
cd sigrank-mcp
npm install

# Run CLI
node index.mjs                        # TUI (if TTY)
node cli.mjs board --once             # leaderboard one-shot

# Or link globally for `sigrank` command
npm link
sigrank

Repo: SunrisesIllNeverSee/sigrank-mcp Site: signalaf.com npm: sigrank Smithery: smithery.ai/servers/burnmydays/sigrank Glama: glama.ai/mcp/servers/SunrisesIllNeverSee/sigrank-mcp

---

Install via Smithery

SigRank is available on Smithery as a stdio MCP bundle — one-click install for Claude Desktop, Cursor, and other MCP clients.

Smithery CLI

# Install Smithery CLI
npm install -g smithery

# Connect to SigRank (downloads the MCPB bundle locally)
smithery mcp add burnmydays/sigrank --id sigrank

# List available tools
smithery tool list sigrank

# Call a tool
smithery tool call sigrank get_leaderboard '{}'
smithery tool call sigrank rank_paste '{"text": "1000000 500000 50000 800000"}'

Claude Desktop (via Smithery)

1. Go to smithery.ai/servers/burnmydays/sigrank
2. Click Install
3. Smithery handles the rest — no manual config editing

---

Commands

⊙ SigRank CLI  v0.0.177

Default (no args)
  sigrank              unified dashboard: cascade + token pillars + board

Commands
  enroll                   sign in: paste a connect code (get one at signalaf.com → Settings)
  submit                   publish your verified runs to the board (sign in first)
  board                    live leaderboard (refreshes every 30s)
  board --window 7d        board for a specific window (7d, 30d, 90d, all)
  board --once             print once and exit
  compare                  raw pillar audit: tokenpull vs ccusage vs token-dash vs tokscale
  compare --platform codex compare for a specific platform
  tui                      full tabbed TUI: Dashboard / Trends / Compare / Board / Watch / Connect
  tui --platform codex     TUI with a different default platform
  watch                    live tune meter — ALL active platforms × all windows, every 30s
  watch --platform codex   watch only one platform (optional filter)
  watch --window 7d        watch only one window (optional filter)

Options
  --window    7d · 30d · 90d · all  (default: 30d for board; all windows for watch)
  --platform  claude · codex · amp · gemini · opencode · goose · …
  --refresh   poll interval in seconds (default: 30)
  --once      print once and exit (board only)

For AI clients (not typeable)
  In a piped/non-TTY context, sigrank is an MCP stdio server.
  AI clients (Claude, Cursor, …) call its tools automatically — these are
  NOT shell commands. Humans use the commands above.

Examples
  sigrank                        # unified dashboard
  sigrank board                  # live leaderboard
  sigrank compare                # pillar audit (claude)
  sigrank compare --platform codex
  sigrank watch --window 7d --refresh 60
  sigrank board --window all --once

The TUI is the whole app

Launch it and sign in inside it:

npx sigrank

Six tabs. Keys: 1-6 or ← → to switch · R refresh · Q quit.

Tab	Key	Content
Dashboard	1	Cascade table (all platforms × windows + combined) · Υ sparklines · token composition bars · mini board
Trends	2	Every metric across windows — sub-views: You / Platform / Field
Compare	3	4-source pillar audit (tokenpull vs ccusage vs token-dash vs tokscale) · delta % · cascade metrics per source · cache read bar chart
Board	4	Full leaderboard with all fields · [W] cycles window (7d/30d/90d/all)
Watch	5	In-TUI landing panel · [Enter] launches the live watcher (big numbers + pillar bars + Υ trend, auto-refreshes 30s)
Connect	6	Sign in / switch device — paste a connect code from signalaf.com → Settings. Then [S] submits.

Sign in + submit

sigrank enroll          # sign in: paste a connect code (get one at signalaf.com → Settings)
sigrank submit          # publish your verified runs to the board (sign in first)
sigrank submit --dry-run  # inspect the exact signed payload without sending anything

Or do it inside the TUI on the Connect tab (6), then press [S] to submit.

---

MCP Server mode

When stdout is not a TTY (i.e. piped to an AI client), sigrank starts an MCP stdio server automatically. AI clients (Claude Code, Cursor, Windsurf, etc.) use this path.

Add to .mcp.json or equivalent:

{
  "mcpServers": {
    "sigrank": {
      "command": "npx",
      "args": ["-y", "sigrank"]
    }
  }
}

Or if installed globally:

{
  "mcpServers": {
    "sigrank": {
      "command": "sigrank"
    }
  }
}

Tools

Tool	Args	What
rank_paste(text)	{input, output, cacheCreate, cacheRead} JSON or 4 whitespace-delimited numbers	Scores token pillars → Υ Yield / SNR / Leverage / Velocity / 10xDEV / Class + prose narration card
get_leaderboard()	{window?}	Live board from signalaf.com — sorted by Υ Yield
get_operator(codename)	{codename}	One operator's live profile
submit_paste(text, codename)	{text, codename?}	Rank locally then POST to board. Omit codename for preview-only
tokenpull(platform?)	{platform?}	On-device local reader: scans local logs → 4-window cascade. Zero paste, token-only
tokenpull_submit(codename, window?)	{codename?, window?}	tokenpull → publish to board. Omit codename for preview
tokenpull_compare(platform?)	{platform?}	All four sources side-by-side: tokenpull + ccusage + token-dash + tokscale. Returns pillars, cascade metrics, and delta % vs tokenpull per window
rank_windows	{platform?, window?}	Multi-window cascade from local logs
watch_tokenpull	{platform?, interval_s?}	One cascade snapshot per call (interval_s advisory)
submit_verified	{window?, platform?, dry_run?}	THE ranked path: builds + ed25519-signs Schema 1.0 snapshots and POSTs them. platform:'multi' sums all active platforms. dry_run:true returns the exact payload unsent
enroll	{code, device_label?}	Bind this device with a connect code from signalaf.com → Settings
diagnose_cascade	{text?}	Diagnoses where your token cascade is leaking efficiency — ranked findings with severity + estimated Υ impact
simulate_change	{text?, changes}	Prescriptive "what if" — test proposed pillar changes and see the exact Υ delta + class change before committing
suggest_improvements	{text?}	Generates ranked, simulated improvement suggestions — tests strategies and returns them sorted by Υ yield impact
self_improve	{text?}	One-click optimize: diagnoses, suggests, and simulates the best change in a single call
get_best_operator(n?)	{n?}	Top N operators with behavioral framing in power-user language. Intent: "who is the best AI user?"
compare_self(codename? | text?)	{codename?} or {text?}	Your metrics vs board averages + power-user assessment + percentile + suggestion. Intent: "how do I measure up?"
compare_operators(a, b)	{codename_a, codename_b}	Side-by-side comparison with behavioral verdict. Intent: "compare operator X vs Y"
describe_power_user()	{}	Static explanation of AI power user archetype + metrics explained. Intent: "what is an AI power user?"
optimize_efficiency(codename? | text?)	{codename?} or {text?}	Ranked efficiency suggestions tied to your cascade shape. Intent: "how can I use AI more efficiently?"
tokscale_breakdown(threshold?)	{threshold?}	Per-model token breakdown across platforms (models under threshold → "other")
tokscale_market_share()	{}	AI tool market share: each tool's % of tokens/cost/messages, ranked. From local tokscale data
tokscale_developer_profile()	{}	Per-developer usage profile across all detected tools: model mix, pillars, sessions, workspaces. Paths redacted
tokscale_model_trends()	{}	Model adoption over time: per-model first/last seen, active days, month-by-month adoption curve
tokscale_cost_analysis()	{}	Cost per developer per model: cost_per_million_tokens, cost_per_message, share_cost, client rollup
tokscale_device_profile()	{}	Device fingerprinting: installed tools, session counts, active days, day-of-week distribution, concurrency. Paths redacted
tokscale_mcp_usage()	{}	MCP server usage: detected servers, detection window, active days
tokscale_competitive_intel(target)	{target}	Competitive intelligence for any AI tool: rank, model mix, cost efficiency, share vs all competitors

---

Cascade math

Υ Yield    = (cache_read × output) / input²
SNR        = output / (input + output)
Leverage   = cache_read / input
Velocity   = output / input
10xDEV     = log₁₀(leverage)

Math is in cascade.mjs, dependency-free. Mirrors sigrank-app/lib/ingest/bridge.ts. Canon check: MO§ES (1251211, 11296121, 128196310, 2555179769) → Υ 18436.98.

---

Token Pillars — sources

The dashboard pulls from multiple sources and shows them side-by-side for verification:

Source	What	Platform
tokenpull	On-device JSONL scanner (canon source)	claude, codex, amp, …
ccusage	ccusage <platform> daily --json CLI (bundled)	claude, codex
token-dashboard	~/.claude/token-dashboard.db SQLite (Nate's)	claude only
tokscale	tokscale models --json CLI (bundled, falls back to ~/tokscale_report.json)	claude, codex

Non-Claude input is estimated — most non-Claude systems (Codex, Devin, etc.) combine user input + cache write into a single input_tokens field, so true fresh input must be derived. The ruleset (applies to ALL non-Claude systems):

input       = output × ioRatio         (ioRatio derived from Claude ratio, else 2.0)
cacheCreate = uncached − input         (uncached = input_tokens − cached_input_tokens)
cacheRead   = exact (from logs)

• Beta = operator's Claude input/output ratio (if Claude data available)
• Alpha = 2.0 default (when no Claude data)
• Owner-stated average: 7:1:2 (cache:input:output) → input/output ≈ 0.5

Verifier numbers (ccusage/tokscale for codex) show raw uncached input (input_tokens − cached) — a different field than the estimated input above. The discrepancy is expected and explained inline in the dashboard.

---

Platform adapters

All adapters are token-only (no message content, no cost fields, no credentials).

Platform	Path	Notes
Claude Code	✅ ~/.claude/projects	Native; dedup by (session_id, message_id); subagents included
Codex	✅ ~/.codex/sessions	Estimated input via io_ratio; verified vs ccusage
Devin CLI	✅ ~/.local/share/devin/cli/sessions.db	Estimated input via io_ratio; SQLite; same split as Codex
Amp	✅ ~/.local/share/amp/threads	Full 4-pillar; per-message
Kimi	✅ ~/.kimi/sessions	Full 4-pillar; StatusUpdate lines only
pi-agent	✅ ~/.pi/agent/sessions	Full 4-pillar; per-message JSONL
OpenClaw	✅ ~/.openclaw	Full 4-pillar; per-message JSONL
Droid	✅ ~/.factory/sessions/*.settings.json	Full 4-pillar; thinking→output
Codebuff	✅ ~/.config/manicode	Full 4-pillar; chat-messages.json
Hermes	✅ ~/.hermes/state.db	Full 4-pillar; SQLite; reasoning→output
Kilo	✅ ~/.local/share/kilo/kilo.db	Full 4-pillar; SQLite
Qwen	✅ ~/.qwen/projects	cacheCreate=0 estimated; thought→output
Goose	✅ ~/.local/share/goose/sessions/sessions.db	cacheCreate=cacheRead=0 estimated; SQLite
Gemini CLI	✅ ~/.gemini/tmp	cacheCreate=0 estimated; cache extracted from input field
GitHub Copilot CLI	✅ ~/.copilot/otel	OTel JSONL; requires COPILOT_OTEL_ENABLED=true
OpenCode	⚠️ ~/.local/share/opencode	Raw token counts not persisted in log format
Cursor	🔜	Chat log path TBD
Windsurf	🔜	Session logs at ~/.codeium/windsurf/

estimated=true means one or more pillars are derived, not native. The server re-scores all submitted pillars authoritatively; local preview Υ is indicative only.

---

Privacy

• Token-only, always. No message content is ever read, logged, or transmitted — only token counts (input, output, cache_creation, cache_read), message IDs, and timestamps.
• Local by default. tokenpull reads only ~/.claude/projects (Claude) or ~/.codex (Codex) on your device. Numbers stay on your machine unless you explicitly submit with a codename.
• Background tooling excluded. Memory plugins, observers, summarizers (e.g. claude-mem, mem0, observer-sessions) are filtered from both Claude and Codex reads. subagents/ are kept — they represent real operator work.
• Board reads are anonymous. No account needed to browse, compare, or watch.
• Ranked submissions are signed, not trusted. sigrank submit requires a one-time enroll (device-bound ed25519 key — the private key never leaves your machine). Verify what's sent with sigrank submit --dry-run: the payload is four token counts, ratios, and a signature.

---

Env vars

Var	Default	Description
SIGRANK_API_BASE	https://signalaf.com	Override the board host
SIGRANK_FETCH_TIMEOUT	10000	Board API fetch timeout (ms)

---

Dev / test

node test.mjs          # 13 test groups, 200 assertions (no network, no fs writes)
node sign.test.mjs     # ed25519 signing + canon parity
node index.mjs         # stdio MCP server directly (pipe to MCP client)

Tests verify (13 groups, 200 assertions):

• rank_paste canon: MO§ES (1251211, 11296121, 128196310, 2555179769) → Υ 18436.98 · TRANSMITTER
• submit_paste preview (no codename) + POST shape (injected fetch, no live writes)
• tokenpull dedup, window slicing, 4-window pillars (mock adapter)
• tokenpull_submit all 4 windows POST, sha256 hash, ddmmyy stamp
• tokenpullCodex io_ratio conversion per-window
• Adapter registry (15 platforms) + per-adapter shape contracts
• rank_windows 4-window paste scoring, partial input, no-network
• watch_tokenpull cascade snapshot, interval_s, submit path
• enroll posts identity (public key only), maps 201 enrolled + 410 code_invalid
• submit_verified signs Schema 1.0, server-verifiable
• simulate_change relative + absolute deltas, quadratic penalty, JSON input
• Hardening: div-by-zero guards, parsePillars warnings, fetch timeout, EXCLUDE_TOOLING regex, narrate safety
• sign.test.mjs ed25519 round-trip + canonical 926-byte payload parity

---

File map

File	Responsibility
index.mjs	Entry point — TTY detection, routes to CLI or MCP server
cli.mjs	CLI commands: board, compare, watch, enroll, submit, help
tui.mjs	Full tabbed TUI: Dashboard / Trends / Compare / Board / Watch / Connect
cascade.mjs	Pure cascade math (Υ, SNR, leverage, velocity, 10xDEV, class)
tokenpull.mjs	On-device log scanner — Claude, Codex, multi-platform
adapters.mjs	Platform adapter registry (15+ platforms)
tools.mjs	MCP tool table + dispatcher
connect.mjs	Connect-code enrollment + device identity
keystore.mjs	Local key management (paste-keys, not API keys)
submit.mjs	Verified submit flow (signs + POSTs to board)
sign.mjs	Schema 1.0 signing (X-Agent-Signature)
narrate.mjs	Deterministic prose narration card
preflight.mjs	Plausibility checks (Benford, bounds, anomaly detection)
test.mjs	Unit tests (no external deps)
sign.test.mjs	ed25519 signing + canon parity test

---

Contributing

Contributions welcome. SigRank MCP is built in the open.

• Contributing guide
• Security policy
• Report bugs via GitHub Issues
• PRs: fork → branch → node test.mjs passes → open PR against main

License

MIT — see LICENSE.