sigrank 0.18.5 → 1.0.1

package/keystore.mjs

@@ -1,242 +1 @@
-// keystore.mjs — local ed25519 device identity for SigRank signed submit (D7 §4.5).
-//
-// Persists a per-device keypair at ~/.sigrank-mcp/identity.json (dir 0700, file 0600).
-// The PRIVATE key never leaves this machine; only the raw 32-byte public key (as
-// "ed25519:<base64>") is sent to the server at enroll time. The device_id (uuid) is
-// generated once and is the immutable binding target server-side.
-//
-// Public-key export MUST match the server's publicKeyFromAgent: generateKeyPairSync
-// exports SPKI DER with a 12-byte prefix; we strip it to the raw 32 bytes, base64 it,
-// and prefix "ed25519:". The server re-adds the SPKI prefix to verify. Round-trip is
-// locked by sign.test.mjs + the canon-parity fixture.
-
-import { homedir } from "node:os";
-import { join } from "node:path";
-import {
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  existsSync,
-  chmodSync,
-  unlinkSync,
-  readdirSync,
-  copyFileSync,
-} from "node:fs";
-import { generateKeyPairSync, randomUUID } from "node:crypto";
-
-const DIR = join(homedir(), ".sigrank-mcp");
-const PATH = join(DIR, "identity.json");
-const BACKUP_PREFIX = "identity.json.bak-";
-const MAX_BACKUPS = 5;
-
-/** SPKI DER prefix length for an ed25519 public key (12 bytes before the raw 32). */
-const SPKI_PREFIX_LEN = 12;
-
-/** Resolve this package's version for the agent_version stamp (best-effort). */
-function agentVersion() {
-  try {
-    const pkg = JSON.parse(
-      readFileSync(new URL("./package.json", import.meta.url), "utf-8"),
-    );
-    return `sigrank-mcp/${pkg.version}`;
-  } catch {
-    return "sigrank-mcp";
-  }
-}
-
-export function keystorePath() {
-  return PATH;
-}
-
-/** Read the stored identity, or null if absent/corrupt. */
-export function loadIdentity() {
-  if (!existsSync(PATH)) return null;
-  try {
-    return JSON.parse(readFileSync(PATH, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-
-/** Write the identity with strict perms (dir 0700, file 0600). Backs up the existing
- * file before overwriting so a corrupt write or accidental reset can be recovered. */
-export function persistIdentity(identity) {
-  mkdirSync(DIR, { recursive: true });
-  try {
-    chmodSync(DIR, 0o700);
-  } catch {
-    /* best-effort on platforms without chmod */
-  }
-  // Back up the existing identity before overwriting (resilience: if the write
-  // fails or the file is later lost, the backup carries the binding + keys).
-  if (existsSync(PATH)) {
-    try {
-      const stamp = Date.now();
-      copyFileSync(PATH, join(DIR, `${BACKUP_PREFIX}${stamp}`));
-      pruneBackups();
-    } catch {
-      /* best-effort — don't block the write */
-    }
-  }
-  writeFileSync(PATH, `${JSON.stringify(identity, null, 2)}\n`, {
-    mode: 0o600,
-  });
-  try {
-    chmodSync(PATH, 0o600);
-  } catch {
-    /* best-effort */
-  }
-  return identity;
-}
-
-/** Build a fresh keypair record (pure — no fs). Exposed for tests. */
-export function generateIdentity({ device_id } = {}) {
-  const { publicKey, privateKey } = generateKeyPairSync("ed25519");
-  const spki = publicKey.export({ type: "spki", format: "der" });
-  const rawPub = Buffer.from(spki).subarray(SPKI_PREFIX_LEN); // the raw 32 bytes
-  const pkcs8 = privateKey.export({ type: "pkcs8", format: "der" });
-  return {
-    device_id: device_id || randomUUID(),
-    codename: null,
-    operator_id: null,
-    public_key: `ed25519:${rawPub.toString("base64")}`,
-    private_key_pkcs8_b64: Buffer.from(pkcs8).toString("base64"),
-    agent_version: agentVersion(),
-    enrolled_at: null,
-  };
-}
-
-/**
- * Decide the binding (codename/operator_id/enrolled_at) to carry onto a freshly
- * generated identity. The binding is tied to device_id: if device_id is CHANGING
- * (a new device, e.g. after a reset/re-enroll where the old file was deleted), the
- * old binding is INVALIDATED — never preserve a stale codename/operator onto a
- * different device. That mismatch is the "Frankenstein identity" root cause: a new
- * device_id + an old codename → the server sees a mismatch → tags submissions
- * `unverified` → never ranks, yet `isSignedIn` reads the local codename as present.
- * Only reuse the binding when the SAME device_id is being kept. Pure — exposed for
- * tests (no fs, so the owner's live identity is never at risk during a test run).
- */
-export function bindingForFreshIdentity(existing, fresh) {
-  if (!existing)
-    return { codename: null, operator_id: null, enrolled_at: null };
-  if (existing.device_id && fresh.device_id === existing.device_id) {
-    return {
-      codename: existing.codename ?? null,
-      operator_id: existing.operator_id ?? null,
-      enrolled_at: existing.enrolled_at ?? null,
-    };
-  }
-  // device_id changed → the old binding belongs to a different device; drop it.
-  return { codename: null, operator_id: null, enrolled_at: null };
-}
-
-/**
- * Load the existing identity, or generate + persist a fresh one. Idempotent: a
- * complete existing identity is returned untouched (never rotates a live key).
- * Self-healing: if the identity has keys + device_id but no codename (binding
- * lost via partial write / version transition), scans backups for a matching
- * device_id and restores the binding before returning.
- */
-export function ensureIdentity() {
-  const existing = loadIdentity();
-  if (
-    existing?.private_key_pkcs8_b64 &&
-    existing?.public_key &&
-    existing?.device_id
-  ) {
-    // Self-healing: keys present but binding lost → try to restore from backups.
-    if (!existing.codename || !existing.operator_id) {
-      const restored = restoreBindingFromBackups(existing.device_id);
-      if (restored) {
-        existing.codename = restored.codename;
-        existing.operator_id = restored.operator_id;
-        existing.enrolled_at = restored.enrolled_at;
-        return persistIdentity(existing);
-      }
-    }
-    return existing;
-  }
-  // Regeneration path: a partial/corrupt record. The binding is tied to device_id —
-  // if a new device_id is generated, the old codename/operator MUST NOT carry over
-  // (bindingForFreshIdentity drops them). Only a reused device_id keeps its binding.
-  const fresh = generateIdentity({ device_id: existing?.device_id });
-  const binding = bindingForFreshIdentity(existing, fresh);
-  fresh.codename = binding.codename;
-  fresh.operator_id = binding.operator_id;
-  fresh.enrolled_at = binding.enrolled_at;
-  return persistIdentity(fresh);
-}
-
-/** Record a successful enrollment (codename/operator_id + enrolled_at) into the keystore. */
-export function recordEnrollment({ codename, operator_id }) {
-  const id = ensureIdentity();
-  // OVERWRITE from the server's enroll response — a new enroll is a new binding, full
-  // stop. Never `??`-preserve a stale codename/operator onto this device (the other
-  // half of the Frankenstein bug: a re-enroll used to keep the old codename when the
-  // new one was absent). A 201 enrolled always carries both.
-  id.codename = codename ?? null;
-  id.operator_id = operator_id ?? null;
-  id.enrolled_at = new Date().toISOString();
-  return persistIdentity(id);
-}
-
-/** Clear the local identity (sign out). Next enroll provisions a fresh device_id. */
-export function clearIdentity() {
-  try {
-    if (existsSync(PATH)) unlinkSync(PATH);
-  } catch {
-    /* best-effort */
-  }
-}
-
-/** Keep at most MAX_BACKUPS backup files (oldest deleted first). */
-function pruneBackups() {
-  try {
-    const files = readdirSync(DIR)
-      .filter((f) => f.startsWith(BACKUP_PREFIX))
-      .sort(); // timestamp-suffixed → lexicographic = chronological
-    while (files.length > MAX_BACKUPS) {
-      unlinkSync(join(DIR, files.shift()));
-    }
-  } catch {
-    /* best-effort */
-  }
-}
-
-/** Scan backup files for one with the same device_id that carries a codename +
- * operator_id binding. Returns { codename, operator_id, enrolled_at } or null.
- * Used by ensureIdentity() to self-heal when the live file lost its binding
- * (e.g. a partial write or version transition that preserved keys but dropped
- * the binding metadata). Only restores from a backup with the SAME device_id —
- * never crosses device boundaries (Frankenstein-identity guard). */
-export function restoreBindingFromBackups(device_id) {
-  if (!device_id) return null;
-  try {
-    const files = readdirSync(DIR)
-      .filter((f) => f.startsWith(BACKUP_PREFIX))
-      .sort()
-      .reverse(); // newest first — prefer the most recent binding
-    for (const f of files) {
-      try {
-        const bak = JSON.parse(readFileSync(join(DIR, f), "utf-8"));
-        if (
-          bak.device_id === device_id &&
-          bak.codename &&
-          bak.operator_id
-        ) {
-          return {
-            codename: bak.codename,
-            operator_id: bak.operator_id,
-            enrolled_at: bak.enrolled_at ?? null,
-          };
-        }
-      } catch {
-        /* skip corrupt backups */
-      }
-    }
-  } catch {
-    /* best-effort */
-  }
-  return null;
-}
+export * from './identity/keystore.mjs';

package/lib/constants.mjs

@@ -0,0 +1,137 @@
+// lib/constants.mjs — repo-wide constants that were previously inlined as
+// literals across multiple files. Centralizing them here means a version bump
+// or a client-map update lands in exactly one place.
+//
+//   TERMS_VERSION / PRIVACY_VERSION — embedded in every enroll + submit
+//     payload (tools/enroll.mjs, tools/submit-paste.mjs,
+//     tools/tokenpull-submit.mjs, submit/index.mjs). They were inlined as
+//     "2026-07-21" in four files; a terms rev would have required finding
+//     and editing all four. Now: one export, imported everywhere.
+//
+//   TOKSCALE_CLIENT_MAP — maps tokscale's raw client names to our platform
+//     IDs. Was duplicated verbatim in tools/index.mjs and
+//     tools/tokscale-breakdown.mjs (and again in tokscale_analytics.mjs);
+//     the three copies had already started to drift. One export here.
+//
+//   isRankedAck — the "actually on the board" predicate (verified + persisted).
+//     Was inlined as `ack.verification_tier === "verified" && ack.persisted
+//     === true` in submit-paste, tokenpull-submit, and submit/index.mjs, with
+//     tokenpull-submit's multi-platform branch using a DIFFERENT looser
+//     predicate (`ack?.ranked ?? ack?.accepted ?? false`). One predicate here
+//     closes that loophole so every submit path agrees on what "ranked" means.
+
+/** Current Terms of Service version the client attests to. */
+export const TERMS_VERSION = "2026-07-21";
+
+/** Current Privacy Policy version the client attests to. */
+export const PRIVACY_VERSION = "2026-07-21";
+
+/**
+ * The leaderboard sort metric the client requests from the server. Every
+ * leaderboard fetch site (tools/get-leaderboard.mjs, presentation/cli.mjs
+ * fetchBoard, presentation/tui.mjs, compare-self / optimize-efficiency /
+ * get-best-operator / compare-operators) MUST use this value — the server
+ * ranks by `yield_` and a different metric string would either 400 or return
+ * an unsorted board. Centralized here so a future metric rename lands in one
+ * place; the contract test in __tests__/contract/leaderboard-metric-contract.test.mjs
+ * guards against intra-repo drift and (in CI) cross-repo drift vs sigrank-app.
+ */
+export const LEADERBOARD_METRIC = "yield_";
+
+/**
+ * Map a raw tokscale `client` string to our canonical platform ID.
+ * Values mapped to `null` are skipped (synthetic / non-attributable).
+ * Values mapped to `"other"` have no native adapter and bucket together.
+ */
+export const TOKSCALE_CLIENT_MAP = {
+  claude: "claude",
+  codex: "codex",
+  "devin-cli": "devin",
+  "devin-desktop": "devin",
+  gemini: "gemini",
+  amp: "amp",
+  kimi: "kimi",
+  qwen: "qwen",
+  goose: "goose",
+  kilo: "kilo",
+  kilocode: "kilo",
+  hermes: "hermes",
+  droid: "droid",
+  codebuff: "codebuff",
+  copilot: "copilot",
+  opencode: "opencode",
+  openclaw: "openclaw",
+  pi: "pi",
+  omp: "omp",
+  "oh-my-pi": "omp",
+  cursor: "other",
+  roocode: "other",
+  mux: "other",
+  crush: "other",
+  antigravity: "other",
+  "antigravity-cli": "other",
+  zed: "other",
+  kiro: "other",
+  trae: "other",
+  warp: "other",
+  cline: "other",
+  "9router": "other",
+  gjc: "other",
+  grok: "other",
+  jcode: "other",
+  commandcode: "other",
+  micode: "other",
+  junie: "other",
+  zcode: "other",
+  opencodereview: "other",
+  codebuddy: "other",
+  workbuddy: "other",
+  senpi: "other",
+  augment: "other",
+  kimchi: "other",
+  reasonix: "other",
+  "prime-agent": "other",
+  freebuff: "other",
+  synthetic: null,
+};
+
+/**
+ * Platforms whose local data tokscale CANNOT see, so `tokscale models --json`
+ * never lists them as an active client. pullActivePlatforms() auto-detect must
+ * probe these directly or their cascade row can never appear, even with GBs of
+ * native local telemetry (that was exactly the omp bug: tokscale reports
+ * claude/codex/copilot/gemini/grok/kimi/kiro/opencode/pi and nothing else, so
+ * a tokscale-detected machine silently dropped oh-my-pi entirely).
+ *
+ * The adapter pull itself filters out platforms with no data, so probing a
+ * platform the operator doesn't use costs one cheap missing-directory walk.
+ *
+ * As of 2026-08-08: oh-my-pi. Delete an entry once tokscale reports that client
+ * (TOKSCALE_CLIENT_MAP already maps the `omp` / `oh-my-pi` client names for
+ * when that happens).
+ */
+export const TOKSCALE_BLIND_PLATFORMS = ["omp"];
+
+/**
+ * The "actually on the board" predicate. A submission is ranked only when the
+ * server returns HTTP ok AND verification_tier === "verified" AND persisted
+ * === true. An unenrolled/revoked device gets 202 but is NEVER ranked.
+ *
+ * Use this everywhere a submit path decides whether to surface `ranked: true`.
+ * The previous tokenpull-submit multi-platform branch used a looser
+ * `ack?.ranked ?? ack?.accepted ?? false` which would mark a non-persisted
+ * 202 as ranked — this predicate closes that loophole.
+ *
+ * @param {{ ok: boolean }} res  the fetch Response (or { ok } shim)
+ * @param {Record<string, unknown>} ack  the parsed JSON ack body
+ * @returns {boolean}
+ */
+export function isRankedAck(res, ack) {
+  return !!(
+    res &&
+    res.ok &&
+    ack &&
+    ack.verification_tier === "verified" &&
+    ack.persisted === true
+  );
+}

package/lib/pkg-version.mjs

@@ -0,0 +1,59 @@
+// lib/pkg-version.mjs — single source of truth for the package version.
+//
+// Resolves the repo-root package.json by walking up from this module until it
+// finds the package named "sigrank". This is robust to callers in any
+// subdirectory (identity/, submit/, presentation/, tools/, scripts/) — the
+// previous per-caller `new URL("./package.json", import.meta.url)` lookups
+// resolved relative to the CALLER's own directory and hit non-existent files,
+// falling back to a bare string. The agent_version stamp rides inside the
+// SIGNED submit payload (agent.agent_version), so a wrong/missing version
+// there is a high-priority bug — it survived because no test guarded it.
+//
+// One implementation, imported everywhere. Never throws: returns "unknown" on
+// any failure so a missing/renamed package.json never breaks a submit.
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The published package name (package.json "name"). Used to identify the
+ *  repo-root package.json unambiguously past any nested package.json. */
+const REPO_PKG_NAME = "sigrank";
+
+/** Resolve the repo-root package version (best-effort).
+ *  Returns the version string (e.g. "0.0.181") or "unknown" on any failure. */
+export function pkgVersion() {
+  try {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 20; i++) {
+      const pkgPath = join(dir, "package.json");
+      let pkg;
+      try {
+        pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      } catch {
+        // no package.json here — walk up
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+        continue;
+      }
+      if (pkg.name === REPO_PKG_NAME) return pkg.version || "unknown";
+      // Found a package.json but it isn't ours (e.g. a nested dep) — keep walking.
+      const parent = dirname(dir);
+      if (parent === dir) {
+        // Reached the filesystem root without matching; use whatever we found.
+        return pkg.version || "unknown";
+      }
+      dir = parent;
+    }
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/** The full agent-version stamp, e.g. "sigrank-mcp/0.0.181".
+ *  This is the value embedded in the signed payload's agent.agent_version. */
+export function agentVersion() {
+  return `sigrank-mcp/${pkgVersion()}`;
+}

package/manifest.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://raw.githubusercontent.com/anthropics/mcpb/main/schemas/mcpb-manifest-v0.4.schema.json",
+  "manifest_version": "0.4",
+  "name": "sigrank",
+  "version": "1.0.0",
+  "description": "Ranks AI coding operators by token cascade efficiency (Yield = cache_read \u00d7 output / input\u00b2). 23 tools for yield calculation, local token usage pulls, signed submission, and tokscale-powered analytics (market share, developer profiles, model trends, cost analysis, device profiles, MCP usage, competitive intelligence). Privacy-first: runs locally, only four token counts leave the machine.",
+  "author": {
+    "name": "SunrisesIllNeverSee",
+    "url": "https://github.com/SunrisesIllNeverSee"
+  },
+  "homepage": "https://signalaf.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SunrisesIllNeverSee/sigrank-mcp"
+  },
+  "license": "MIT",
+  "server": {
+    "type": "node",
+    "entry_point": "index.mjs",
+    "mcp_config": {
+      "command": "npx",
+      "args": [
+        "sigrank"
+      ],
+      "env": {
+        "SIGRANK_API_BASE": "https://signalaf.com"
+      }
+    }
+  },
+  "user_config": {
+    "SIGRANK_API_BASE": {
+      "type": "string",
+      "title": "SigRank API Base URL",
+      "description": "Overrides the board host for the SigRank API. Defaults to https://signalaf.com.",
+      "default": "https://signalaf.com",
+      "required": false
+    }
+  },
+  "compatibility": {
+    "platforms": [
+      "darwin",
+      "win32",
+      "linux"
+    ]
+  }
+}

package/narrate.mjs

@@ -1,77 +1 @@
-/**
- * narrate.mjs — deterministic prose "card" for a cascade result.
- *
- * Port of _template() from ~/Desktop/moses-sigrank/narrate.py. The model path
- * (MiniCPM4-0.5B) is intentionally SKIPPED: the template is the trustworthy,
- * instant, auditable fallback — same numbers in → same card out, and it can never
- * emit a metric the cascade didn't produce. A model hook can layer behind this same
- * narrate() interface later without a rewrite.
- *
- * Token-only. No network, no randomness.
- */
-
-// Safe formatters: never emit NaN/Infinity/undefined into the card.
-const safeNum = (n) => (Number.isFinite(Number(n)) ? Number(n) : null);
-const comma = (n, dec) => {
-  const v = safeNum(n);
-  return v !== null
-    ? v.toLocaleString("en-US", {
-        minimumFractionDigits: dec,
-        maximumFractionDigits: dec,
-      })
-    : "—";
-};
-const plain = (n, dec) => {
-  const v = safeNum(n);
-  return v !== null ? v.toFixed(dec) : "—";
-};
-
-/**
- * Given a cascade result ({ velocity, leverage, dev10x, pillars, class }) and an
- * optional subject name, return "**CLASS.** <one or two sentences>". Deterministic.
- */
-export function narrate(cascade, name = "This operator") {
-  const klass = cascade.class || cascade.klass || "UNCLASSED";
-  const v = safeNum(cascade.velocity);
-  const l = safeNum(cascade.leverage);
-
-  // "non-compounding" = a stateless pipe: no cache commits, so the cascade can't
-  // form. cascade.mjs leaves dev10x null when cacheCreate is 0 (the cw/o term
-  // collapses), which is exactly metrics.py's non_compounding flag.
-  // Also catches zero-input sessions where velocity/leverage are null.
-  const cw = cascade.pillars ? Number(cascade.pillars.cacheCreate) : NaN;
-  const nonCompounding =
-    cascade.dev10x == null || !(cw > 0) || v === null || l === null;
-
-  let body;
-  if (nonCompounding) {
-    const leverageStr =
-      l !== null
-        ? `Leverage ${comma(l, 1)}x comes from reuse alone.`
-        : "Leverage is undefined (no fresh input recorded).";
-    const dev10xNote =
-      cascade.dev10x == null
-        ? " 10xDEV is undefined — the compounding loop has not formed yet."
-        : "";
-    body =
-      `${name} runs a stateless pipe — no cache commits, so the cascade can't form. ` +
-      `High read volume, but nothing is being built forward. ${leverageStr}${dev10xNote}`;
-  } else if (v >= 1 && l >= 100) {
-    body =
-      `${name} holds both axes at once: ${plain(v, 1)}x generation AND ${comma(l, 0)}x memory leverage. ` +
-      `A closed kinetic loop — the rare operator the leverage/generation tradeoff says shouldn't exist.`;
-  } else if (l >= 10 && v < 1) {
-    body =
-      `${name} is an archival sponge — ${comma(l, 0)}x reuse but only ${plain(v, 2)}x generation. ` +
-      `Holds context beautifully, executes little with it. The reuse number is inflated by a weak commitment stage.`;
-  } else if (v >= 0.8 && l < 2) {
-    body =
-      `${name} is a volatile ingestor — ${plain(v, 2)}x generation but ${plain(l, 1)}x leverage. ` +
-      `Fast on single shots, resets between turns. Memory doesn't persist into a compounding loop.`;
-  } else {
-    body =
-      `${name} sits low on both axes: ${plain(v, 2)}x generation, ${plain(l, 1)}x leverage. ` +
-      `A transient profile — neither building state nor converting input to output efficiently.`;
-  }
-  return `**${klass}.** ${body}`;
-}
+export * from './presentation/narrate.mjs';

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "sigrank",
-  "version": "0.18.5",
+  "version": "1.0.1",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
-  "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
+  "description": "SigRank MCP server — AI operator evaluation and token cascade efficiency tools. The yield cascade + live leaderboard as MCP tools any agent can call.",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",
   "type": "module",
   "license": "MIT",
@@ -24,26 +24,43 @@
   },
   "scripts": {
     "start": "node index.mjs",
-    "test": "node test.mjs && node sign.test.mjs && node --test __tests__/cascade.test.mjs __tests__/badges.test.mjs",
-    "sync:platforms": "node scripts/sync-platforms.mjs"
+    "test": "node test.mjs && node __tests__/sign.test.mjs && node --test __tests__/cascade.test.mjs __tests__/badges.test.mjs __tests__/tui-input.test.mjs",
+    "sync:platforms": "node scripts/sync-platforms.mjs",
+    "sync:spine": "node scripts/sync-spine.mjs",
+    "spine:check": "node scripts/sync-spine.mjs --check",
+    "spine:diff": "node scripts/sync-spine.mjs --dry-run"
   },
   "files": [
     "index.mjs",
-    "cli.mjs",
-    "tui.mjs",
-    "tools.mjs",
+    "proxy.mjs",
+    "lib/",
+    "tools/",
+    "analytics/",
+    "identity/",
+    "submit/",
+    "adapters/",
+    "presentation/",
+    "resources/",
+    "prompts/",
+    "badges.mjs",
+    "review.mjs",
     "cascade.mjs",
-    "narrate.mjs",
-    "tokenpull.mjs",
-    "adapters.mjs",
-    "sign.mjs",
     "keystore.mjs",
-    "submit.mjs",
+    "sign.mjs",
     "connect.mjs",
-    "badges.mjs",
+    "submit.mjs",
     "preflight.mjs",
-    "banner.svg",
+    "adapters.mjs",
+    "tokenpull.mjs",
+    "tui.mjs",
+    "cli.mjs",
+    "narrate.mjs",
+    "tools.mjs",
+    "tokscale_analytics.mjs",
+    "manifest.json",
     "README.md",
+    "CHANGELOG.md",
+    "MCP_SERVER_DESCRIPTION.md",
     "LICENSE"
   ],
   "keywords": [
@@ -65,7 +82,15 @@
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "ccusage": "^20.0.17",
-    "tokscale": "^4.5.2"
+    "@sigrank/cascade": "^0.1.1",
+    "ccusage": "^20.0.19",
+    "tokscale": "^4.7.0"
+  },
+  "devDependencies": {
+    "@resvg/resvg-js": "^2.6.2",
+    "gifenc": "^1.0.3"
+  },
+  "overrides": {
+    "@hono/node-server": "^2.0.5"
   }
 }