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

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

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.

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.

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

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

Platform

Path

Pillar shape & notes

Claude Code

✅ ~/.claude/projects (recursive, incl. subagents/)

Native 4-pillar; dedup by (session_id, message_id) — final snapshot wins

Codex

✅ ~/.codex/sessions (+ archived_sessions)

input_tokens incl. cached → input + cacheCreate split window-level via io_ratio; cacheRead native (cached_input_tokens); reasoning_output→output; verified vs ccusage (~1%)

Devin CLI

✅ ~/.local/share/devin/cli/sessions.db

SQLite; native 4-pillar from metadata.metrics (input_tokens, output_tokens, cache_read_tokens, cache_creation_tokens); input_tokens is fresh (excludes cache)

Amp

✅ ~/.local/share/amp/threads

Native 4-pillar; per-message

Kimi

✅ ~/.kimi/sessions

Native 4-pillar; StatusUpdate lines only

pi-agent

✅ ~/.pi/agent/sessions

Native 4-pillar; per-message JSONL

oh-my-pi (omp)

✅ ~/.omp/agent/sessions (recursive, incl. nested subagent transcripts)

Native 4-pillar from .message.usage on type:"message" entries (cacheWrite→cacheCreate); reasoningTokens is already inside output — never added, or it double-counts; usage.cost reuses the same four key names for USD floats and is dropped; dedup by (session header id, entry id). Separate harness from pi-agent

OpenClaw

✅ ~/.openclaw

Native 4-pillar; per-message JSONL

Droid

✅ ~/.factory/sessions/*.settings.json

Native 4-pillar; thinking_tokens→output

Codebuff

✅ ~/.config/manicode

Native 4-pillar; chat-messages.json

Hermes

✅ ~/.hermes/state.db

Native 4-pillar; SQLite; reasoning_tokens→output

Kilo

✅ ~/.local/share/kilo/kilo.db

Native 4-pillar; SQLite

Qwen

✅ ~/.qwen/projects

Estimated (cacheCreate=0 — no field in logs); cacheRead from cachedContentTokenCount; thoughtsTokenCount→output

Goose

✅ ~/.local/share/goose/sessions/sessions.db (or $GOOSE_PATH_ROOT/data/sessions/sessions.db)

Estimated (cacheCreate=cacheRead=0 — no cache fields); reasoning = total−input−output→output; cumulative-column dedup by session id

Gemini CLI

✅ ~/.gemini/tmp

Estimated (cacheCreate=0); cacheRead from cached field; thought→output; input = input−cached (fresh)

GitHub Copilot CLI

✅ ~/.copilot/otel

Native 4-pillar (OTel spans: llm.token_count.{prompt,completion,cache_creation,cache_read}); requires COPILOT_OTEL_ENABLED=true + COPILOT_OTEL_EXPORTER_TYPE=file set before session start

OpenCode

⚠️ ~/.local/share/opencode

Data gap — logs store cost:0 and derive tokens via LiteLLM at runtime; raw token counts not persisted. No pillars readable with current format

SigRank proxy

✅ ~/.sigrank-mcp/proxy-sessions.jsonl

Opt-in native 4-pillar usage reported by Anthropic/OpenAI; same-timestamp records keep the last call; OpenAI cached input is separated from fresh input

Other (user JSON)

✅ $SIGRANK_OTHER_PATH

User-supplied JSON { "windows": { "all": {input,output,cacheCreate,cacheRead} } }; all-time only (no timestamps)

Cursor

🔜

Chat log path TBD

Windsurf

🔜

Session logs at ~/.codeium/windsurf/

Var

Default

Description

SIGRANK_API_BASE

https://signalaf.com

Override the board host

SIGRANK_FETCH_TIMEOUT

10000

Board API fetch timeout (ms)

File

Responsibility

index.mjs

Entry point — TTY detection, routes to CLI or MCP server

proxy.mjs

Opt-in loopback Anthropic/OpenAI proxy and usage capture

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 (16+ 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