sigrank 0.0.216 → 0.0.218

package/manifest.json

@@ -2,7 +2,7 @@
   "$schema": "https://raw.githubusercontent.com/anthropics/mcpb/main/schemas/mcpb-manifest-v0.4.schema.json",
   "manifest_version": "0.4",
   "name": "sigrank",
-  "version": "0.0.215",
+  "version": "0.0.217",
   "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.0.216",
+  "version": "0.0.218",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "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",

package/presentation/tui.mjs

@@ -341,6 +341,21 @@ async function loadDashboardData({ includeOmp = false } = {}) {
     new Promise((r) => setTimeout(() => r(null), 5000)),
   ]);
 
+  // Batched windows: fetch the signed-in operator's rolled-forward totals
+  // (never decrease when platforms delete old logs). Only fetched when signed in.
+  const id = loadIdentity();
+  const batchedPromise = (id && isSignedIn(id))
+    ? Promise.race([
+        fetch(`${DEFAULT_API_BASE}/api/v1/operators/${encodeURIComponent(id.codename)}`, {
+          headers: { accept: "application/json" },
+        })
+          .then((r) => (r.ok ? r.json() : null))
+          .then((d) => d?.batched ?? null)
+          .catch(() => null),
+        new Promise((r) => setTimeout(() => r(null), 5000)),
+      ])
+    : Promise.resolve(null);
+
   // FIX 0 + unify (0.14): progressive load via the SHARED loader (pullActivePlatforms) — paint the
   // primary platform (claude) FAST, then fill the rest in fillDashboardRest. This is the SAME loader
   // `me` and `watch` use, so the three views can't drift apart. (Verifier comparison still runs
@@ -350,11 +365,13 @@ async function loadDashboardData({ includeOmp = false } = {}) {
   );
 
   const boardData = await boardPromise;
+  const batchedData = await batchedPromise;
   return {
     active,
     verifierMap: {},
     tdPillars: null,
     boardData,
+    batchedData,
     _loading: true,
     _remaining: dashboardEnabledPlatforms({
       includeManual: includeOmp,
@@ -743,8 +760,8 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
   // which is what was starving codex's cascade rows after the Your-Read/Three-Degrees panels landed.)
   const platformCount = active.length;
   const barLines = 4 + platformCount + (platformCount > 1 ? 1 : 0); // Token Composition: hr + header + platforms + combined + note
-  // Your Read (hr+header+~3 wins+1 gap = 6) + Four Degrees (blank+hr+header+col-header+5 rows+note = 10) + status
-  const boardLines = 17;
+  // Your Read (hr+header+up to 4 wins+up to 5 gaps+summary = 13) + Four Degrees (blank+hr+header+col-header+5 rows+note = 10) + Lifetime Tokens (blank+hr+header+platforms+combined+note = ~7) + status
+  const boardLines = 24;
   const sectionsBelow = barLines + boardLines;
   const maxCascadeRows = Math.max(8, budget - used - sectionsBelow);
 
@@ -923,24 +940,38 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
     if (you) {
       const wins = [],
         gaps = [];
-      const chk = (label, val, fieldAvg, top, fmt, tip) => {
+      let aboveHcm = 0,
+        abovePower = 0,
+        totalMetrics = 0;
+      // Three-tier comparison: HCM (field median) → Power (top-100 median) → Top (best operator)
+      const chk = (label, val, hcm, power, top, fmt, tip) => {
         if (val == null) return;
-        if (val >= top * 0.9)
+        totalMetrics++;
+        if (val >= top * 0.9) {
           wins.push(`${label} ${fmt(val)} — ${gold("top tier")}`);
-        else if (val >= fieldAvg)
-          wins.push(`${label} ${fmt(val)} — above field avg`);
-        else
+          aboveHcm++;
+          abovePower++;
+        } else if (val >= power) {
+          wins.push(`${label} ${fmt(val)} — ${paint(c.boldCyan, "power-user tier")}`);
+          aboveHcm++;
+          abovePower++;
+        } else if (val >= hcm) {
+          wins.push(`${label} ${fmt(val)} — above field, ${dim("approaching power-user")}`);
+          aboveHcm++;
+        } else {
           gaps.push({
             label,
-            txt: `${label} ${fmt(val)} — below field (${fmt(fieldAvg)}): ${tip}`,
+            txt: `${label} ${fmt(val)} — below field (${fmt(hcm)}): ${tip}`,
             val,
-            fieldAvg,
+            hcm,
           });
+        }
       };
       chk(
         "Υ Yield",
         you.yield,
         TD.hcm.yield,
+        TD.power.yield,
         TD.top.yield,
         fmtY,
         "compound more — reuse cache, raise output",
@@ -949,6 +980,7 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
         "SNR",
         you.snr,
         TD.hcm.snr,
+        TD.power.snr,
         TD.top.snr,
         fmtSNR,
         "tighten prompts — less input per unit output",
@@ -957,6 +989,7 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
         "Leverage",
         you.leverage,
         TD.hcm.lev,
+        TD.power.lev,
         TD.top.lev,
         (v) => fmtLev(v) + "×",
         "lean on cache-read — amplify prior context",
@@ -965,17 +998,39 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
         "Velocity",
         you.velocity,
         TD.hcm.vel,
+        TD.power.vel,
         TD.top.vel,
         (v) => v.toFixed(2),
         "more output per input token",
       );
-      for (const w of wins.slice(0, 3)) emit(`    ${paint(c.green, "▲")} ${w}`);
-      // weakest gap gets the prescriptive tip
-      const weakest = gaps.sort(
-        (a, b) => a.val / a.fieldAvg - b.val / b.fieldAvg,
-      )[0];
-      if (weakest) emit(`    ${paint(c.magenta, "▽")} ${dim(weakest.txt)}`);
-      if (!wins.length && !weakest) emit(`    ${dim("  building your read…")}`);
+      chk(
+        "10xDEV",
+        you.dev10x,
+        TD.hcm.d10,
+        TD.power.d10,
+        TD.top.d10,
+        (v) => v.toFixed(2),
+        "raise leverage — every 10× lev adds 1 to 10xDEV",
+      );
+      for (const w of wins.slice(0, 4)) emit(`    ${paint(c.green, "▲")} ${w}`);
+      // all gaps shown; weakest gets the prescriptive tip
+      const sortedGaps = gaps.sort(
+        (a, b) => a.val / a.hcm - b.val / b.hcm,
+      );
+      for (let i = 0; i < sortedGaps.length; i++) {
+        const g = sortedGaps[i];
+        if (i === 0) emit(`    ${paint(c.magenta, "▽")} ${dim(g.txt)}`);
+        else emit(`    ${paint(c.magenta, "▽")} ${dim(g.label + " below field")}`);
+      }
+      if (!wins.length && !sortedGaps.length) emit(`    ${dim("  building your read…")}`);
+      // summary line — where you sit across all metrics
+      if (totalMetrics > 0) {
+        const hcmStr = `${aboveHcm}/${totalMetrics}`;
+        const pwrStr = `${abovePower}/${totalMetrics}`;
+        emit(
+          `    ${dim(`above HCM on ${bold(hcmStr)} · above Power on ${bold(pwrStr)}`)}`,
+        );
+      }
     } else {
       emit(`    ${dim("  reading your cascade… (press [R] to refresh)")}`);
     }
@@ -1019,6 +1074,49 @@ function renderDashboard(data, status = "", scrollOffset = 0) {
     );
   }
 
+  // ── Lifetime Tokens — submission-based rolled-forward totals (never decrease)
+  // Shows when the operator is signed in and has submission history. The batched
+  // data comes from the server (computeBatchedWindows over snapshot_submissions).
+  const batched = data?.batchedData;
+  if (batched && used < budget - 4) {
+    const fmtT = (n) => {
+      if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+      if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+      if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+      return String(n);
+    };
+    const total = (p) => (p?.input ?? 0) + (p?.output ?? 0) + (p?.cacheCreate ?? 0) + (p?.cacheRead ?? 0);
+    emit();
+    emit(`  ${hr()}`);
+    emit(`  ${bold("Lifetime Tokens")}  ${dim("archived submissions · never decreases")}`);
+    const platforms = Object.entries(batched.per_platform ?? {});
+    for (const [plat, pw] of platforms) {
+      if (used >= budget - 2) break;
+      const pc = platformColor(plat);
+      const allT = total(pw.all);
+      const d90T = total(pw["90d"]);
+      emit(
+        `    ${padEnd(pc(plat), 10)}  ${padStart(fmtT(allT), 8)} total  ${dim("·")}  ${padStart(fmtT(d90T), 8)} in last 90d`,
+      );
+    }
+    if (platforms.length > 1) {
+      const cAll = total(batched.combined?.all);
+      const c90 = total(batched.combined?.["90d"]);
+      emit(
+        `    ${padEnd(bold("combined"), 10)}  ${padStart(bold(fmtT(cAll)), 8)} total  ${dim("·")}  ${padStart(bold(fmtT(c90)), 8)} in last 90d`,
+      );
+    }
+    // Find the earliest baseline date across platforms
+    const baselineDates = platforms.map(([, pw]) => pw.baseline_date).filter(Boolean).sort();
+    const subCounts = platforms.map(([, pw]) => pw.submission_count ?? 0);
+    const totalSubs = subCounts.reduce((a, b) => a + b, 0);
+    if (baselineDates.length > 0) {
+      emit(
+        `    ${dim(`${totalSubs} submission${totalSubs !== 1 ? "s" : ""} archived · baseline ${baselineDates[0].slice(0, 10)}`)}`,
+      );
+    }
+  }
+
   if (status && used < budget) emit(`  ${dim(status)}`);
 }
 

package/tools/_schemas.mjs

@@ -118,6 +118,74 @@ export const OPERATOR_OUTPUT = {
         },
       },
     },
+    batched: {
+      type: "object",
+      description:
+        "Submission-based rolled-forward totals (never decrease when platforms delete old logs). Present when the operator has submission history.",
+      properties: {
+        per_platform: {
+          type: "object",
+          description: "Per-platform batched windows",
+          additionalProperties: {
+            type: "object",
+            properties: {
+              "90d": {
+                type: "object",
+                description: "Rolled-forward 90d pillars (sum of batches <=90 days old)",
+                properties: {
+                  input: { type: "integer" },
+                  output: { type: "integer" },
+                  cacheCreate: { type: "integer" },
+                  cacheRead: { type: "integer" },
+                },
+              },
+              all: {
+                type: "object",
+                description: "All-time pillars (baseline + all deltas — never decreases)",
+                properties: {
+                  input: { type: "integer" },
+                  output: { type: "integer" },
+                  cacheCreate: { type: "integer" },
+                  cacheRead: { type: "integer" },
+                },
+              },
+              submission_count: {
+                type: "integer",
+                description: "Number of archived submissions for this platform",
+              },
+              baseline_date: {
+                type: "string",
+                description: "ISO date of the first (baseline) submission",
+              },
+            },
+          },
+        },
+        combined: {
+          type: "object",
+          description: "Combined batched windows across all platforms",
+          properties: {
+            "90d": {
+              type: "object",
+              properties: {
+                input: { type: "integer" },
+                output: { type: "integer" },
+                cacheCreate: { type: "integer" },
+                cacheRead: { type: "integer" },
+              },
+            },
+            all: {
+              type: "object",
+              properties: {
+                input: { type: "integer" },
+                output: { type: "integer" },
+                cacheCreate: { type: "integer" },
+                cacheRead: { type: "integer" },
+              },
+            },
+          },
+        },
+      },
+    },
   },
 };