sigrank 0.15.5 → 0.16.1

package/connect.mjs

@@ -4,10 +4,10 @@
 
 /** True iff this device identity is signed in (bound to an operator). */
 export function isSignedIn(id) {
-  return !!(id && id.codename && id.operator_id)
+  return !!(id && id.codename && id.operator_id);
 }
 
 /** True iff `s` is a single character a connect code can contain ([A-Za-z0-9-]). */
 export function isCodeChar(s) {
-  return typeof s === 'string' && /^[A-Za-z0-9-]$/.test(s)
+  return typeof s === "string" && /^[A-Za-z0-9-]$/.test(s);
 }

package/index.mjs

@@ -21,8 +21,8 @@
  * Token-only — no transcript content.
  */
 
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
@@ -30,130 +30,149 @@ import {
   GetPromptRequestSchema,
   McpError,
   ErrorCode,
-} from '@modelcontextprotocol/sdk/types.js'
-import { TOOLS, callTool } from './tools.mjs'
-import { runCli } from './cli.mjs'
-import { readFileSync } from 'node:fs'
+} from "@modelcontextprotocol/sdk/types.js";
+import { TOOLS, callTool } from "./tools.mjs";
+import { runCli } from "./cli.mjs";
+import { readFileSync } from "node:fs";
 
 // FIX K: read the version from package.json (was hardcoded '0.7.0' — drifted from
 // 0.11.0). The MCP server identity now tracks the published package version.
 function serverVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'))
-    return pkg.version || '0.0.0'
+    const pkg = JSON.parse(
+      readFileSync(new URL("./package.json", import.meta.url), "utf-8"),
+    );
+    return pkg.version || "0.0.0";
   } catch {
-    return '0.0.0'
+    return "0.0.0";
   }
 }
 
 // Prevent silent crashes — log to stderr (MCP clients read stdout; stderr is safe for
 // diagnostics). The process exits so the client can respawn with a clean slate rather
 // than hanging on a broken connection.
-process.on('uncaughtException', (err) => {
-  process.stderr.write(`[sigrank-mcp] uncaughtException: ${err?.stack || err}\n`)
-  process.exit(1)
-})
-process.on('unhandledRejection', (reason) => {
-  process.stderr.write(`[sigrank-mcp] unhandledRejection: ${reason?.stack || reason}\n`)
-  process.exit(1)
-})
+process.on("uncaughtException", (err) => {
+  process.stderr.write(
+    `[sigrank-mcp] uncaughtException: ${err?.stack || err}\n`,
+  );
+  process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+  process.stderr.write(
+    `[sigrank-mcp] unhandledRejection: ${reason?.stack || reason}\n`,
+  );
+  process.exit(1);
+});
 
 async function startMcpServer() {
   const server = new Server(
-    { name: 'sigrank', version: serverVersion() },
+    { name: "sigrank", version: serverVersion() },
     { capabilities: { tools: {}, prompts: {} } },
-  )
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }))
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS,
+  }));
   server.setRequestHandler(CallToolRequestSchema, async (req) => {
     // Unknown tool name = a client/host bug → JSON-RPC -32602 protocol error, per the MCP
     // spec. isError results (below) are reserved for tools that ran and failed.
     if (!TOOLS.some((t) => t.name === req.params.name)) {
-      throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${req.params.name}`)
+      throw new McpError(
+        ErrorCode.InvalidParams,
+        `Unknown tool: ${req.params.name}`,
+      );
     }
     try {
-      const out = await callTool(req.params.name, req.params.arguments)
-      return { content: [{ type: 'text', text: JSON.stringify(out, null, 2) }] }
+      const out = await callTool(req.params.name, req.params.arguments);
+      return {
+        content: [{ type: "text", text: JSON.stringify(out, null, 2) }],
+      };
     } catch (e) {
-      return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true }
+      return {
+        content: [{ type: "text", text: `Error: ${e.message}` }],
+        isError: true,
+      };
     }
-  })
+  });
 
   // --- Prompts: interactive templates that agents can offer to users ---
   const PROMPTS = [
     {
-      name: 'check-my-efficiency',
+      name: "check-my-efficiency",
       description:
-        'Pull your local token usage, compute your SigRank yield, and compare your efficiency against the leaderboard. Shows your class tier (Burner/Builder/10xer) and where you rank.',
+        "Pull your local token usage, compute your SigRank yield, and compare your efficiency against the leaderboard. Shows your class tier (Burner/Builder/10xer) and where you rank.",
       arguments: [],
     },
     {
-      name: 'simulate-improvement',
+      name: "simulate-improvement",
       description:
         'Run a what-if analysis on your token mix: "if I increased my cache reads by 50k, how would my yield change?" Uses simulate_change to show the payoff before you change your workflow.',
       arguments: [
         {
-          name: 'change',
-          description: 'The change to simulate (e.g. "increase cache reads by 50000" or "reduce input by 100000")',
+          name: "change",
+          description:
+            'The change to simulate (e.g. "increase cache reads by 50000" or "reduce input by 100000")',
           required: true,
         },
       ],
     },
     {
-      name: 'compare-with-leader',
+      name: "compare-with-leader",
       description:
-        'Fetch the top operator from the SigRank leaderboard and compare their token efficiency metrics against yours. Shows the gap and what you\'d need to change to close it.',
+        "Fetch the top operator from the SigRank leaderboard and compare their token efficiency metrics against yours. Shows the gap and what you'd need to change to close it.",
       arguments: [],
     },
-  ]
+  ];
 
-  server.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }))
+  server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: PROMPTS,
+  }));
   server.setRequestHandler(GetPromptRequestSchema, async (req) => {
-    const name = req.params.name
-    const args = req.params.arguments || {}
-    if (name === 'check-my-efficiency') {
+    const name = req.params.name;
+    const args = req.params.arguments || {};
+    if (name === "check-my-efficiency") {
       return {
         messages: [
           {
-            role: 'user',
+            role: "user",
             content: {
-              type: 'text',
-              text: 'Pull my local token usage with tokenpull, compute my yield, and then fetch the leaderboard so I can see where I rank. Show me my class tier and my key metrics (Yield, Leverage, Velocity).',
+              type: "text",
+              text: "Pull my local token usage with tokenpull, compute my yield, and then fetch the leaderboard so I can see where I rank. Show me my class tier and my key metrics (Yield, Leverage, Velocity).",
             },
           },
         ],
-      }
+      };
     }
-    if (name === 'simulate-improvement') {
-      const change = args.change || 'increase cache reads by 50000'
+    if (name === "simulate-improvement") {
+      const change = args.change || "increase cache reads by 50000";
       return {
         messages: [
           {
-            role: 'user',
+            role: "user",
             content: {
-              type: 'text',
+              type: "text",
               text: `First pull my local token usage with tokenpull to get my current pillars. Then use simulate_change to answer: "what if I ${change}?" Show me the yield delta and whether my class tier would change.`,
             },
           },
         ],
-      }
+      };
     }
-    if (name === 'compare-with-leader') {
+    if (name === "compare-with-leader") {
       return {
         messages: [
           {
-            role: 'user',
+            role: "user",
             content: {
-              type: 'text',
-              text: 'Fetch the SigRank leaderboard with get_leaderboard, then pull my local token usage with tokenpull. Compare my yield, leverage, and velocity against the top operator. What\'s the gap and what would I need to change to close it?',
+              type: "text",
+              text: "Fetch the SigRank leaderboard with get_leaderboard, then pull my local token usage with tokenpull. Compare my yield, leverage, and velocity against the top operator. What's the gap and what would I need to change to close it?",
             },
           },
         ],
-      }
+      };
     }
-    throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${name}`)
-  })
+    throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${name}`);
+  });
 
-  await server.connect(new StdioServerTransport())
+  await server.connect(new StdioServerTransport());
 }
 
 // Route:
@@ -161,13 +180,13 @@ async function startMcpServer() {
 //                          so a typo never silently starts a hung MCP stdio server on a TTY)
 //   no args + TTY stdout → full tabbed TUI (interactive use)
 //   no args + piped      → MCP stdio server (AI client use)
-const cliArgs = process.argv.slice(2)
+const cliArgs = process.argv.slice(2);
 if (cliArgs.length > 0) {
-  runCli(process.argv)
+  runCli(process.argv);
 } else if (process.stdout.isTTY) {
   // Interactive terminal — launch the full tabbed TUI
-  const { runTui } = await import('./tui.mjs')
-  runTui()
+  const { runTui } = await import("./tui.mjs");
+  runTui();
 } else {
-  startMcpServer()
+  startMcpServer();
 }

package/keystore.mjs

@@ -10,73 +10,84 @@
 // 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 } from 'node:fs'
-import { generateKeyPairSync, randomUUID } from 'node:crypto'
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  chmodSync,
+  unlinkSync,
+} from "node:fs";
+import { generateKeyPairSync, randomUUID } from "node:crypto";
 
-const DIR = join(homedir(), '.sigrank-mcp')
-const PATH = join(DIR, 'identity.json')
+const DIR = join(homedir(), ".sigrank-mcp");
+const PATH = join(DIR, "identity.json");
 
 /** SPKI DER prefix length for an ed25519 public key (12 bytes before the raw 32). */
-const SPKI_PREFIX_LEN = 12
+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}`
+    const pkg = JSON.parse(
+      readFileSync(new URL("./package.json", import.meta.url), "utf-8"),
+    );
+    return `sigrank-mcp/${pkg.version}`;
   } catch {
-    return 'sigrank-mcp'
+    return "sigrank-mcp";
   }
 }
 
 export function keystorePath() {
-  return PATH
+  return PATH;
 }
 
 /** Read the stored identity, or null if absent/corrupt. */
 export function loadIdentity() {
-  if (!existsSync(PATH)) return null
+  if (!existsSync(PATH)) return null;
   try {
-    return JSON.parse(readFileSync(PATH, 'utf-8'))
+    return JSON.parse(readFileSync(PATH, "utf-8"));
   } catch {
-    return null
+    return null;
   }
 }
 
 /** Write the identity with strict perms (dir 0700, file 0600). */
 export function persistIdentity(identity) {
-  mkdirSync(DIR, { recursive: true })
+  mkdirSync(DIR, { recursive: true });
   try {
-    chmodSync(DIR, 0o700)
+    chmodSync(DIR, 0o700);
   } catch {
     /* best-effort on platforms without chmod */
   }
-  writeFileSync(PATH, `${JSON.stringify(identity, null, 2)}\n`, { mode: 0o600 })
+  writeFileSync(PATH, `${JSON.stringify(identity, null, 2)}\n`, {
+    mode: 0o600,
+  });
   try {
-    chmodSync(PATH, 0o600)
+    chmodSync(PATH, 0o600);
   } catch {
     /* best-effort */
   }
-  return identity
+  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' })
+  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'),
+    public_key: `ed25519:${rawPub.toString("base64")}`,
+    private_key_pkcs8_b64: Buffer.from(pkcs8).toString("base64"),
     agent_version: agentVersion(),
     enrolled_at: null,
-  }
+  };
 }
 
 /**
@@ -91,16 +102,17 @@ export function generateIdentity({ device_id } = {}) {
  * 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)
+    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 }
+  return { codename: null, operator_id: null, enrolled_at: null };
 }
 
 /**
@@ -108,35 +120,43 @@ export function bindingForFreshIdentity(existing, fresh) {
  * complete existing identity is returned untouched (never rotates a live key).
  */
 export function ensureIdentity() {
-  const existing = loadIdentity()
-  if (existing?.private_key_pkcs8_b64 && existing?.public_key && existing?.device_id) {
-    return existing
+  const existing = loadIdentity();
+  if (
+    existing?.private_key_pkcs8_b64 &&
+    existing?.public_key &&
+    existing?.device_id
+  ) {
+    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)
+  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()
+  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)
+  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 */ }
+  try {
+    if (existsSync(PATH)) unlinkSync(PATH);
+  } catch {
+    /* best-effort */
+  }
 }

package/narrate.mjs

@@ -11,55 +11,67 @@
  */
 
 // Safe formatters: never emit NaN/Infinity/undefined into the card.
-const safeNum = (n) => (Number.isFinite(Number(n)) ? Number(n) : null)
+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 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) : '—'
-}
+  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)
+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
+  const cw = cascade.pillars ? Number(cascade.pillars.cacheCreate) : NaN;
+  const nonCompounding =
+    cascade.dev10x == null || !(cw > 0) || v === null || l === null;
 
-  let body
+  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.' : ''
+    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}`
+      `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.`
+      `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.`
+      `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.`
+      `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.`
+      `A transient profile — neither building state nor converting input to output efficiently.`;
   }
-  return `**${klass}.** ${body}`
+  return `**${klass}.** ${body}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.15.5",
+  "version": "0.16.1",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",
   "type": "module",
@@ -23,7 +23,7 @@
   },
   "scripts": {
     "start": "node index.mjs",
-    "test": "node test.mjs && node sign.test.mjs"
+    "test": "node test.mjs && node sign.test.mjs && node --test __tests__/cascade.test.mjs __tests__/badges.test.mjs"
   },
   "files": [
     "index.mjs",
@@ -38,6 +38,8 @@
     "keystore.mjs",
     "submit.mjs",
     "connect.mjs",
+    "badges.mjs",
+    "preflight.mjs",
     "banner.svg",
     "README.md",
     "LICENSE"