sigrank 0.0.182 → 0.0.184

package/analytics/cascade.mjs

@@ -61,7 +61,7 @@ export function cascade({ input, output, cacheCreate, cacheRead }) {
     leverage: round(leverage, 1),
     velocity: round(velocity, 3),
     dev10x: round(dev10x, 2),
-    class: classify(yield_, dev10x),
+    class: classify(total),
     mode: detectMode({ input: i, output: o, cacheCreate: cw, cacheRead: cr }),
   };
   if (warnings.length > 0) result.warnings = warnings;
@@ -69,43 +69,121 @@ export function cascade({ input, output, cacheCreate, cacheRead }) {
 }
 
 /**
- * CLASS_TIERS — the canonical 8-tier dev10x taxonomy. SINGLE SOURCE OF TRUTH.
- * Every consumer (presentation/tui.mjs, presentation/cli.mjs, tools/_schemas.mjs,
- * resources/class-tiers.md) imports THIS list instead of maintaining its own.
- * Order is descending (TRANSMITTER at top, IGNITER at bottom) — matches the
- * classify() first-match-wins cut order.
+ * CLASS_TIERS — the 8 base tier names (K.01–K.08) for display: glyph, color,
+ * meaning. SINGLE SOURCE OF TRUTH for tier-level display info.
+ *
+ * The permanent class is an EXPERIENCE ladder keyed on TOTAL TOKENS. Each tier
+ * has 3 sub-stages (I/II/III) — 24 stages total. The 24 thresholds live in
+ * RS05_CLASS_THRESHOLDS below. classify() returns the full sub-stage string
+ * (e.g. "REFINER II"). Use tierOf() to extract the base tier name.
+ *
+ * TRANSMITTER is NOT on this ladder — it is a temporary peak badge (RS.08).
+ * The client does not evaluate the badge (owner is still calibrating it);
+ * the server does it on read.
+ *
+ * Mirrors the server's canon-ids.ts CLASS_TIERS (display) + ruleset.ts
+ * RS05_CLASS_THRESHOLDS (thresholds). Order is descending (ARCH+ → IGNITER).
  */
 export const CLASS_TIERS = [
-  "TRANSMITTER",
   "ARCH+",
   "ARCH",
   "POWER",
   "BASE",
   "SEEKER",
   "REFINER",
+  "BEARER",
   "IGNITER",
 ];
 
-/** The degenerate-case class returned when both yield and dev10x are null
- *  (all-zero / empty session). Distinct from IGNITER (which is a real low
- *  dev10x bucket) so callers can tell "no data" from "bottom tier". */
+/**
+ * SIGNAL_CLASSES — the full 24 sub-stage names (8 tiers × 3 sub-stages I/II/III).
+ * Mirrors the server's SIGNAL_CLASSES set in lib/board/mappers.ts. The API
+ * returns class_tier as one of these 24 values. classify() returns one of these
+ * (or UNCLASSED). Use this for schema enums and validation.
+ */
+export const SIGNAL_CLASSES = [
+  "ARCH+ I", "ARCH+ II", "ARCH+ III",
+  "ARCH I", "ARCH II", "ARCH III",
+  "POWER I", "POWER II", "POWER III",
+  "BASE I", "BASE II", "BASE III",
+  "SEEKER I", "SEEKER II", "SEEKER III",
+  "REFINER I", "REFINER II", "REFINER III",
+  "BEARER I", "BEARER II", "BEARER III",
+  "IGNITER I", "IGNITER II", "IGNITER III",
+];
+
+/**
+ * RS05_CLASS_THRESHOLDS — 24 total-token breakpoints (8 tiers × 3 sub-stages).
+ * Mirrors the server's lib/analytics/ruleset.ts RS05_CLASS_THRESHOLDS exactly.
+ * Calibrated from the HCM cut (1,626 operators) using target distribution
+ * (Option C): IGNITER 10%, BEARER 12.5%, REFINER 15%, SEEKER 22.5%, BASE 20%,
+ * POWER 15%, ARCH 5%, ARCH+ 0% (aspirational). Each tier split into 3
+ * equal-population sub-stages. Update this one constant to stay in parity
+ * when the owner tweaks server-side.
+ */
+export const RS05_CLASS_THRESHOLDS = [
+  { class: "ARCH+ I", totalMin: 7068201104627 },
+  { class: "ARCH+ II", totalMin: 7068201104627 },
+  { class: "ARCH+ III", totalMin: 7068201104627 },
+  { class: "ARCH I", totalMin: 186207267611 },
+  { class: "ARCH II", totalMin: 98543134083 },
+  { class: "ARCH III", totalMin: 68766193943 },
+  { class: "POWER I", totalMin: 39958782379 },
+  { class: "POWER II", totalMin: 26955905621 },
+  { class: "POWER III", totalMin: 19141226889 },
+  { class: "BASE I", totalMin: 13960345961 },
+  { class: "BASE II", totalMin: 10189224970 },
+  { class: "BASE III", totalMin: 7747041813 },
+  { class: "SEEKER I", totalMin: 5446673659 },
+  { class: "SEEKER II", totalMin: 4014577247 },
+  { class: "SEEKER III", totalMin: 2961798768 },
+  { class: "REFINER I", totalMin: 2358346840 },
+  { class: "REFINER II", totalMin: 1845750357 },
+  { class: "REFINER III", totalMin: 1334876308 },
+  { class: "BEARER I", totalMin: 984078167 },
+  { class: "BEARER II", totalMin: 714619043 },
+  { class: "BEARER III", totalMin: 431702990 },
+  { class: "IGNITER I", totalMin: 216393332 },
+  { class: "IGNITER II", totalMin: 88999166 },
+  { class: "IGNITER III", totalMin: 0 },
+];
+
+/** The degenerate-case class returned when totalTokens is null/undefined
+ *  (all-zero / empty session). Distinct from IGNITER III (which is a real
+ *  low-experience tier) so callers can tell "no data" from "bottom tier". */
 export const UNCLASSED = "UNCLASSED";
 
-/** MVP class tiering from Υ + 10xDEV (canon assigns from cascade SNR + 10xDEV; this
- *  is the open-MVP approximation — proprietary threshold cuts stay server-side). */
-export function classify(yieldVal, dev10x) {
-  // Degenerate: all-null (empty session / no pillars) → UNCLASSED, not IGNITER.
-  // Falling through to IGNITER here would mislabel a no-data operator as the
-  // bottom tier; UNCLASSED lets the TUI / narrate surface "no data" instead.
-  if (yieldVal == null && dev10x == null) return UNCLASSED;
-  if (yieldVal >= 1000 || dev10x >= 3) return "TRANSMITTER";
-  if (dev10x >= 1.45) return "ARCH+";
-  if (dev10x >= 1.35) return "ARCH";
-  if (dev10x >= 1.2) return "POWER";
-  if (dev10x >= 1.0) return "BASE";
-  if (dev10x >= 0) return "SEEKER";
-  if (dev10x >= -0.3) return "REFINER";
-  return "IGNITER";
+/** Extract the base tier name from a sub-stage string (e.g. "ARCH+ I" → "ARCH+").
+ *  Mirrors the server's tierOf() in components/sigrank/types.ts. Returns the
+ *  input as-is if it's not a sub-stage string (e.g. UNCLASSED). */
+export function tierOf(cls) {
+  if (cls === UNCLASSED || cls == null) return cls;
+  const parts = String(cls).split(" ");
+  if (parts.length >= 2 && ["I", "II", "III"].includes(parts[parts.length - 1])) {
+    return parts.slice(0, -1).join(" ");
+  }
+  return cls;
+}
+
+/** Extract the sub-stage from a sub-stage string (e.g. "ARCH+ I" → "I").
+ *  Mirrors the server's stageOf(). Returns null for non-sub-stage strings. */
+export function stageOf(cls) {
+  if (cls === UNCLASSED || cls == null) return null;
+  const parts = String(cls).split(" ");
+  const stage = parts[parts.length - 1];
+  return stage === "I" || stage === "II" || stage === "III" ? stage : null;
+}
+
+/** Classify an operator's experience stage from total tokens (input + output +
+ *  cacheCreate + cacheRead). Descending first-match-wins scan over
+ *  RS05_CLASS_THRESHOLDS — mirrors the server's assignClass(totalTokens).
+ *  Returns a full sub-stage string (e.g. "REFINER II") or UNCLASSED. */
+export function classify(totalTokens) {
+  if (totalTokens == null || !Number.isFinite(totalTokens)) return UNCLASSED;
+  for (const t of RS05_CLASS_THRESHOLDS) {
+    if (totalTokens >= t.totalMin) return t.class;
+  }
+  return "IGNITER III";
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigrank",
-  "version": "0.0.182",
+  "version": "0.0.184",
   "author": "SunrisesIllNeverSee (https://github.com/SunrisesIllNeverSee)",
   "description": "SigRank MCP server — the yield cascade + live leaderboard as MCP tools any agent can call",
   "mcpName": "io.github.SunrisesIllNeverSee/sigrank-mcp",

package/presentation/cli.mjs

@@ -15,7 +15,7 @@
  *   npx sigrank watch --window 7d    watch one window only (optional filter)
  *
  * Color palette mirrors the SigRank web dark theme:
- *   gold = class TRANSMITTER headline + rank #1
+ *   gold = rank #1 headline
  *   cyan = active metrics / your row highlight
  *   dim  = secondary data, separators
  *   red  = negative movement / delta
@@ -23,7 +23,7 @@
  */
 
 import { callTool, DEFAULT_API_BASE, pullActivePlatforms } from "../tools.mjs";
-import { cascade, classify, CLASS_TIERS, UNCLASSED } from "../cascade.mjs";
+import { cascade, classify, CLASS_TIERS, UNCLASSED, tierOf } from "../cascade.mjs";
 import { ALL_PLATFORMS } from "../adapters.mjs";
 import { ensureIdentity, keystorePath } from "../keystore.mjs";
 import { submitSignedWindow } from "../submit.mjs";
@@ -90,21 +90,21 @@ const green = (str) => paint(c.green, str);
 const red = (str) => paint(c.red, str);
 
 // ── Class tier → color ─────────────────────────────────────────────────────
-// Built from the canonical CLASS_TIERS list (single source of truth). The dead
-// BEARER entry (no tier by that name exists) was removed; UNCLASSED added for
-// the degenerate no-data case.
+// Color is keyed on the BASE TIER (8 entries in CLASS_TIERS). classify() returns
+// a full sub-stage string (e.g. "REFINER II") — tierOf() extracts the base tier
+// for color lookup. TRANSMITTER is not a class. UNCLASSED for no-data.
 const CLASS_COLOR = {
-  TRANSMITTER: (s) => paint(c.boldGold, s),
   "ARCH+": (s) => paint(c.boldCyan, s),
   ARCH: (s) => paint(c.cyan, s),
   POWER: (s) => paint(c.boldWhite, s),
   BASE: (s) => paint(c.white, s),
   SEEKER: (s) => paint(c.magenta, s),
   REFINER: (s) => paint(c.blue, s),
+  BEARER: (s) => paint(c.dim, s),
   IGNITER: (s) => paint(c.dim, s),
   [UNCLASSED]: (s) => paint(c.dim, s),
 };
-const colorClass = (cls) => (CLASS_COLOR[cls] ?? ((s) => s))(cls);
+const colorClass = (cls) => (CLASS_COLOR[tierOf(cls)] ?? CLASS_COLOR[UNCLASSED] ?? ((s) => s))(cls);
 // Guard: every canonical tier must have a color here.
 for (const t of CLASS_TIERS) {
   if (!CLASS_COLOR[t]) {

package/presentation/tui.mjs

@@ -14,7 +14,7 @@
 
 import { callTool, DEFAULT_API_BASE, pullActivePlatforms } from "../tools.mjs";
 import { ALL_PLATFORMS } from "../adapters.mjs";
-import { cascade, CLASS_TIERS, UNCLASSED } from "../cascade.mjs";
+import { cascade, CLASS_TIERS, UNCLASSED, tierOf } from "../cascade.mjs";
 import { freshVerifierPillars } from "../tokenpull.mjs";
 import { isSignedIn, isCodeChar } from "../connect.mjs";
 import { loadIdentity, clearIdentity } from "../keystore.mjs";
@@ -201,21 +201,21 @@ const fmtMov = (n) =>
   n == null || n === 0 ? dim("—") : n > 0 ? green(`+${n}`) : red(`${n}`);
 
 // ── Class tier colors ────────────────────────────────────────────────────────
-// Built from the canonical CLASS_TIERS list (single source of truth) so a new
-// tier added in analytics/cascade.mjs can't silently lack a color here. The
-// dead BEARER entry (no tier by that name exists) was removed.
+// Color is keyed on the BASE TIER (8 entries in CLASS_TIERS). classify() returns
+// a full sub-stage string (e.g. "REFINER II") — tierOf() extracts the base tier
+// for color lookup. TRANSMITTER is not a class — it's a temporary peak badge.
 const CLS = {
-  TRANSMITTER: (s) => paint(c.boldGold, s),
   "ARCH+": (s) => paint(c.boldCyan, s),
   ARCH: (s) => paint(c.cyan, s),
   POWER: (s) => paint(c.boldWhite, s),
   BASE: (s) => paint(c.white, s),
   SEEKER: (s) => paint(c.magenta, s),
   REFINER: (s) => paint(c.blue, s),
+  BEARER: (s) => paint(c.dim, s),
   IGNITER: (s) => paint(c.dim, s),
   [UNCLASSED]: (s) => paint(c.dim, s),
 };
-const colorCls = (cls) => (CLS[cls] ?? ((s) => s))(cls);
+const colorCls = (cls) => (CLS[tierOf(cls)] ?? CLS[UNCLASSED] ?? ((s) => s))(cls);
 
 // Guard: every canonical tier must have a color, so a new tier added in
 // analytics/cascade.mjs can't silently render uncolored here.

package/resources/class-tiers.md

@@ -1,62 +1,81 @@
 # SigRank Class Tiers
 
-Every operator is classified into one of eight tiers (the **dev10x** taxonomy)
-based on their Yield (Υ = Cache Reads × Output / Input²) and 10xDEV score
-(`log10(T × C × R)` where T = output/input, C = cacheCreate/output,
-R = cacheRead/cacheCreate). The classifier is `classify()` in
-`analytics/cascade.mjs` — the canonical source of truth. The TUI, CLI, MCP
-output schemas, and this doc all read from that one list.
-
-A ninth value, **UNCLASSED**, is returned when both Υ and 10xDEV are null
-(empty / all-zero session). It is distinct from IGNITER so callers can tell
-"no data" from "bottom tier".
-
-## TRANSMITTER (Υ ≥ 1000 or 10xDEV ≥ 3)
-- **Profile:** Cascade-optimized operators. High cache reads, minimal input, efficient output.
-- **Behavior:** Surgical — minimal new input, maximum cache reuse, high-yield output.
-- **Typical:** Power users with long-running sessions, tight context windows, and aggressive cache strategies.
-- **Maintain:** Keep cache hit rate high. Avoid context bloat. Monitor with watch_tokenpull.
-
-## ARCH+ (10xDEV ≥ 1.45)
-- **Profile:** High-leverage architect. Strong compounding loop.
-- **Behavior:** Builds forward aggressively while reusing prior context.
-- **Fix:** Push cache reads higher to cross into TRANSMITTER.
-
-## ARCH (1.35 ≤ 10xDEV < 1.45)
-- **Profile:** Established architect. Solid compounding, room to tighten.
-- **Behavior:** Reliable reuse + generation balance.
-- **Fix:** Increase cacheCreate quality (better summaries, tighter prompts) to reach ARCH+.
-
-## POWER (1.2 ≤ 10xDEV < 1.35)
-- **Profile:** Productive operator with a forming compounding loop.
-- **Behavior:** Moderate cache leverage, decent output efficiency.
-- **Fix:** Reuse sessions more aggressively to lift cache reads.
-
-## BASE (1.0 ≤ 10xDEV < 1.2)
-- **Profile:** Balanced operator. Some cache, decent output efficiency.
-- **Behavior:** Productive — reasonable input-to-output ratio, some cache leverage.
-- **Typical:** Experienced AI coders who use CLAUDE.md, project context, and session continuity.
-- **Fix:** Increase cache reads by reusing sessions. Reduce input by trimming unnecessary context.
-
-## SEEKER (0 ≤ 10xDEV < 1.0)
-- **Profile:** Learning operator. Compounding loop not yet formed.
-- **Behavior:** Exploring — input-heavy, building toward reuse.
-- **Fix:** Commit context to cache (longer sessions, --continue) to start compounding.
-
-## REFINER (-0.3 ≤ 10xDEV < 0)
-- **Profile:** Raw volume operators. High input tokens, low cache reuse.
-- **Behavior:** Brute-force — lots of context fed in, relatively little output back.
-- **Typical:** New AI users, verbose prompters, no session continuity.
-- **Fix:** Build cache across sessions. Stop re-explaining context. Use --continue.
-
-## IGNITER (10xDEV < -0.3)
-- **Profile:** Sub-baseline. Negative compounding — context is being lost faster than it's built.
-- **Behavior:** Each turn re-ingests more than it reuses; the loop runs in reverse.
-- **Fix:** Stop starting fresh sessions. Commit context once and reuse it.
+Every operator is classified into one of **24 experience stages** — 8 tiers ×
+3 sub-stages (I/II/III) — based on their **total tokens** (input + output +
+cacheCreate + cacheRead). The ladder mirrors the server's
+`RS05_CLASS_THRESHOLDS` (`lib/analytics/ruleset.ts` in sigrank-app) — the
+client's `classify()` in `analytics/cascade.mjs` is the canonical local source
+of truth. The TUI, CLI, MCP output schemas, and this doc all read from that
+one list.
+
+The class is an **experience** axis — it measures how much volume the operator
+has accumulated. It is separate from the **cascade archetype** (the operator's
+token-flow shape: kinetic loop, archival sponge, volatile ingestor, etc.) and
+from the **TRANSMITTER peak badge** (a temporary state — see below).
+
+A 25th value, **UNCLASSED**, is returned when total tokens are null or
+non-finite (empty / all-zero session). It is distinct from IGNITER III so
+callers can tell "no data" from "bottom tier".
+
+## The 8 base tiers (K.01–K.08)
+
+Each tier has 3 sub-stages (I/II/III) split by total-token thresholds. The
+sub-stage is the granular experience level; the base tier is the display
+grouping (color, glyph, meaning).
+
+### ARCH+ (K.01) — total ≥ 7.07T
+- **Sub-stages:** ARCH+ I (≥ 7.07T), ARCH+ II (≥ 7.07T), ARCH+ III (≥ 7.07T)
+- **Profile:** Deepest field experience. Volume that became architecture.
+- **Note:** Aspirational — currently 1 operator in the static board.
+
+### ARCH (K.02) — total ≥ 68.8B
+- **Sub-stages:** ARCH I (≥ 186B), ARCH II (≥ 98.5B), ARCH III (≥ 68.8B)
+- **Profile:** System builders. Sustained volume, coherent output.
+
+### POWER (K.03) — total ≥ 19.1B
+- **Sub-stages:** POWER I (≥ 40.0B), POWER II (≥ 27.0B), POWER III (≥ 19.1B)
+- **Profile:** Above the center. Volume compounding.
+
+### BASE (K.04) — total ≥ 7.7B
+- **Sub-stages:** BASE I (≥ 14.0B), BASE II (≥ 10.2B), BASE III (≥ 7.7B)
+- **Profile:** The center of the field. The average operator's experience.
+
+### SEEKER (K.05) — total ≥ 3.0B
+- **Sub-stages:** SEEKER I (≥ 5.4B), SEEKER II (≥ 4.0B), SEEKER III (≥ 3.0B)
+- **Profile:** Approaching the center. Experience accumulating.
+
+### REFINER (K.06) — total ≥ 1.3B
+- **Sub-stages:** REFINER I (≥ 2.4B), REFINER II (≥ 1.8B), REFINER III (≥ 1.3B)
+- **Profile:** Practicing with purpose. Early sustained volume.
+
+### BEARER (K.07) — total ≥ 432M
+- **Sub-stages:** BEARER I (≥ 984M), BEARER II (≥ 715M), BEARER III (≥ 432M)
+- **Profile:** Quiet accumulation. The first real volume.
+
+### IGNITER (K.08) — total ≥ 0
+- **Sub-stages:** IGNITER I (≥ 216M), IGNITER II (≥ 89.0M), IGNITER III (≥ 0)
+- **Profile:** Dormant potential. The still soul. Waiting.
 
 ## UNCLASSED (no data)
 - **Profile:** Empty session — all four pillars are zero.
-- **Behavior:** No tokens recorded for this window.
-- **Fix:** Run some sessions; the tier will resolve once there is data.
+- **Fix:** Run some sessions; the stage will resolve once there is data.
+
+## TRANSMITTER (peak badge, not a class)
+
+TRANSMITTER is **not** on the experience ladder. It is a temporary peak badge
+(RS.08) that any experience tier can earn during a high-frequency,
+high-resonance window. An operator "transmits" when they hit both:
+
+- **High frequency:** token throughput (total tokens in window) ≥ 1B
+- **High resonance:** SIGNA RATE (composite signal quality) ≥ 85
+
+The badge is per-window (daily/weekly) and lapses when frequency or resonance
+drops. The server evaluates it via `evaluateTransmitterBadge()` in
+`lib/analytics/transmitter-badge.ts`; the client does not evaluate the badge
+locally (the owner is still calibrating the thresholds). The server is the
+authority.
+
+---
 
-Tiers are recalculated on every submission. Your tier can change between windows (7d, 30d, 90d, all-time).
+Tiers are recalculated on every submission. Your stage can change between
+windows (7d, 30d, 90d, all-time) as total tokens accumulate.

package/tools/_framing.mjs

@@ -15,28 +15,27 @@
  */
 
 import { DEFAULT_API_BASE } from "./_helpers.mjs";
-import { CLASS_TIERS, UNCLASSED } from "../analytics/cascade.mjs";
+import { CLASS_TIERS, UNCLASSED, tierOf } from "../analytics/cascade.mjs";
 
 /**
- * Map a class tier to a power-user band. The 8 dev10x tiers collapse into 5
+ * Map a class tier to a power-user band. The 8 experience tiers collapse into 5
  * behavioral bands + UNCLASSED so the framing stays short without writing 8
  * bespoke messages. Band order matches CLASS_TIERS cut order (descending).
  *
- *   TRANSMITTER           → apex    (the rare closed-loop operator)
- *   ARCH+, ARCH           → high    (power-user archetype)
+ *   ARCH+, ARCH           → high    (deep experience, power-user archetype)
  *   POWER, BASE           → mid     (building momentum)
- *   SEEKER, REFINER       → early   (compounding, not yet compounding well)
- *   IGNITER               → entry   (tokens burned, not compounded)
+ *   SEEKER, REFINER       → early   (accumulating volume, finding patterns)
+ *   BEARER, IGNITER       → entry   (first volume, or dormant)
  *   UNCLASSED / unknown   → nodata
  */
 const BAND = {
-  TRANSMITTER: "apex",
   "ARCH+": "high",
   ARCH: "high",
   POWER: "mid",
   BASE: "mid",
   SEEKER: "early",
   REFINER: "early",
+  BEARER: "entry",
   IGNITER: "entry",
   [UNCLASSED]: "nodata",
 };
@@ -46,10 +45,12 @@ const BAND = {
  *  silently relabeling every no-data operator as the bottom legacy tier. */
 export const FALLBACK_CLASS = UNCLASSED;
 
-/** Map a class tier to its power-user band. Exported so tool handlers can
- *  branch on band without re-deriving the tier→band mapping. */
+/** Map a class tier (full sub-stage string or base tier) to its power-user
+ *  band. Exported so tool handlers can branch on band without re-deriving the
+ *  tier→band mapping. Uses tierOf() to extract the base tier from sub-stage
+ *  strings (e.g. "REFINER II" → "REFINER" → "early"). */
 export function bandOf(klass) {
-  return BAND[klass] ?? "nodata";
+  return BAND[tierOf(klass)] ?? "nodata";
 }
 
 /**

package/tools/_schemas.mjs

@@ -2,7 +2,7 @@
  * tools/_schemas.mjs — MCP tool annotation + input/output schema objects.
  */
 
-import { CLASS_TIERS, UNCLASSED } from "../analytics/cascade.mjs";
+import { SIGNAL_CLASSES, UNCLASSED } from "../analytics/cascade.mjs";
 
 // Smithery quality: output schemas + annotations
 // MCP tool annotations hint to clients about side-effects, read-only status, etc.
@@ -15,13 +15,13 @@ export const ANNOTATIONS = {
 
 // The canonical class-tier enum, single-sourced from analytics/cascade.mjs.
 // Every output schema that exposes a `class` field uses this so the enum can
-// never drift between tools (the old schemas each inlined ["Burner","Builder",
-// "10xer"] — a 3-tier legacy that didn't match the 8-tier dev10x classifier
-// the cascade actually emits). UNCLASSED is included for the degenerate
-// no-data case. Exported so tool files that declare their own output schema
-// (optimize-efficiency.mjs, describe-power-user.mjs) import the same enum
-// instead of re-inlining a stale tier list.
-export const CLASS_ENUM = [...CLASS_TIERS, UNCLASSED];
+// never drift between tools. SIGNAL_CLASSES is the 24 sub-stage names (8 tiers
+// × 3 sub-stages I/II/III) that classify() emits and the API returns.
+// UNCLASSED is included for the degenerate no-data case. Exported so tool
+// files that declare their own output schema (optimize-efficiency.mjs,
+// describe-power-user.mjs) import the same enum instead of re-inlining a
+// stale tier list.
+export const CLASS_ENUM = [...SIGNAL_CLASSES, UNCLASSED];
 
 // Common output schema for cascade results (rank_paste, simulate_change, etc.)
 // Field names match the actual cascade() output in analytics/cascade.mjs:

package/tools/describe-power-user.mjs

@@ -9,7 +9,7 @@ import { DEFAULT_API_BASE } from "./_helpers.mjs";
 export const TOOL_DEF = {
   name: "describe_power_user",
   description:
-    "Returns an explanatory description of what makes an AI power user, anchored in SigRank's metrics and operator classes. Explains the yield metric, leverage, velocity, and how the 8 class tiers (TRANSMITTER / ARCH+ / ARCH / POWER / BASE / SEEKER / REFINER / IGNITER, plus UNCLASSED for no-data) map to power-user behavior patterns. Use this when users ask 'what is an AI power user?' or 'what makes a good AI user?' or 'describe advanced AI user behavior'. Intent: DESCRIBE_POWER_USER (Informational).",
+    "Returns an explanatory description of what makes an AI power user, anchored in SigRank's metrics and operator classes. Explains the yield metric, leverage, velocity, and how the 8 experience tiers (ARCH+ / ARCH / POWER / BASE / SEEKER / REFINER / BEARER / IGNITER, each with 3 sub-stages I/II/III, plus UNCLASSED for no-data) map to power-user behavior patterns. Use this when users ask 'what is an AI power user?' or 'what makes a good AI user?' or 'describe advanced AI user behavior'. Intent: DESCRIBE_POWER_USER (Informational).",
   annotations: { title: "Describe power user", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.idempotentHint },
   inputSchema: {
     type: "object",
@@ -57,20 +57,19 @@ export async function handleDescribePowerUser() {
       leverage: "Leverage (Cr/I) measures how much you reuse prior work vs starting fresh. High leverage = you're building on cached results, not re-explaining everything.",
       velocity: "Velocity (O/I) measures how much output you get per token spent. High velocity = you're productive, not just active.",
     },
-    // The 8-tier dev10x taxonomy + UNCLASSED, in descending cut order
-    // (matches analytics/cascade.mjs CLASS_TIERS). Each tier carries a
-    // one-line power-user meaning. The legacy 3-tier Burner/Builder/10xer
-    // list is retired — the classifier never emitted those names.
+    // The 8 base tiers + UNCLASSED, in descending cut order (matches
+    // analytics/cascade.mjs CLASS_TIERS). Each tier has 3 sub-stages (I/II/III)
+    // — 24 stages total. TRANSMITTER is a peak badge, not a class.
     class_tiers: [
-      { class: "TRANSMITTER", meaning: "Apex power user — both leverage and velocity held at once. The rare closed-loop operator." },
-      { class: "ARCH+", meaning: "AI power user archetype — disciplined, system-level reuse, high output per input." },
-      { class: "ARCH", meaning: "Power user — heavy cache reuse and strong output velocity." },
-      { class: "POWER", meaning: "Building momentum — moderate-to-high cache reuse, approaching the ARCH band." },
-      { class: "BASE", meaning: "Building momentum — cache reuse starting, velocity solid. Increase reuse to climb." },
-      { class: "SEEKER", meaning: "Compounding, not yet compounding well — cache reuse beginning but input still dominates." },
-      { class: "REFINER", meaning: "Early compounding — low leverage, refining context reuse habits." },
-      { class: "IGNITER", meaning: "Entry — tokens burned more than compounded. The shift: reuse prior context." },
-      { class: UNCLASSED, meaning: "No cascade data yet — run sessions and re-rank to see your tier." },
+      { class: "ARCH+", sub_stages: ["ARCH+ I", "ARCH+ II", "ARCH+ III"], meaning: "Deepest field experience — volume that became architecture. The AI power user archetype." },
+      { class: "ARCH", sub_stages: ["ARCH I", "ARCH II", "ARCH III"], meaning: "System builder — sustained volume, coherent output, heavy cache reuse." },
+      { class: "POWER", sub_stages: ["POWER I", "POWER II", "POWER III"], meaning: "Above the center — volume compounding, building momentum." },
+      { class: "BASE", sub_stages: ["BASE I", "BASE II", "BASE III"], meaning: "The center of the field — the average operator's experience. Building momentum." },
+      { class: "SEEKER", sub_stages: ["SEEKER I", "SEEKER II", "SEEKER III"], meaning: "Approaching the center — experience accumulating, reuse patterns forming." },
+      { class: "REFINER", sub_stages: ["REFINER I", "REFINER II", "REFINER III"], meaning: "Practicing with purpose — early sustained volume, refining context reuse." },
+      { class: "BEARER", sub_stages: ["BEARER I", "BEARER II", "BEARER III"], meaning: "Quiet accumulation — the first real volume. Session continuity starting." },
+      { class: "IGNITER", sub_stages: ["IGNITER I", "IGNITER II", "IGNITER III"], meaning: "Entry — dormant potential. First sessions, minimal accumulated volume." },
+      { class: UNCLASSED, sub_stages: null, meaning: "No cascade data yet — run sessions and re-rank to see your tier." },
     ],
     link: "https://signalaf.com/score — check your class tier and yield",
     shareable_url: `${DEFAULT_API_BASE}/score`,

package/tools/diagnose-cascade.mjs

@@ -55,7 +55,7 @@ export async function handleDiagnoseCascade(args) {
       diagnosis.push({
         metric: "cache_leverage",
         severity: "critical",
-        finding: `Cache leverage is ${leverage}× — you're reading only ${leverage}× your fresh input from cache. TRANSMITTER-class operators hit 200×+.`,
+        finding: `Cache leverage is ${leverage}× — you're reading only ${leverage}× your fresh input from cache. Top-tier operators hit 200×+.`,
         recommendation:
           "Increase context reuse: load prior session context, use longer conversation threads, reference earlier outputs.",
         estimated_yield_impact: `+${Math.round((1 - leverage / 50) * 100)}% Υ potential`,

package/tools/get-leaderboard.mjs

@@ -8,7 +8,7 @@ import { LEADERBOARD_METRIC } from "../lib/constants.mjs";
 export const TOOL_DEF = {
   name: "get_leaderboard",
   description:
-    "Fetches the live public SigRank leaderboard from signalaf.com. Reads all ranked operators sorted by yield (Υ = Cache Reads × Output / Input²) and returns an array of operator summaries. Each entry contains: codename (public display name), yield (Υ, the headline efficiency metric), leverage ratio (Cr/I = cache reads divided by input), velocity (O/I = output divided by input), class tier (one of the 8 dev10x tiers: TRANSMITTER / ARCH+ / ARCH / POWER / BASE / SEEKER / REFINER / IGNITER), and rank position (integer, 1-based). Returns an empty array if no operators have submitted yet. Use this to see where operators stand overall, to find specific codenames for get_operator lookups, or to display the current rankings. Do NOT use this to check your own rank if you already know your codename — use get_operator instead for a single-operator profile with per-window breakdowns. After calling this, follow up with get_operator to get detailed metrics for any operator of interest.",
+    "Fetches the live public SigRank leaderboard from signalaf.com. Reads all ranked operators sorted by yield (Υ = Cache Reads × Output / Input²) and returns an array of operator summaries. Each entry contains: codename (public display name), yield (Υ, the headline efficiency metric), leverage ratio (Cr/I = cache reads divided by input), velocity (O/I = output divided by input), class tier (one of 24 experience stages: 8 tiers × 3 sub-stages, e.g. ARCH+ I, REFINER II, IGNITER III), and rank position (integer, 1-based). Returns an empty array if no operators have submitted yet. Use this to see where operators stand overall, to find specific codenames for get_operator lookups, or to display the current rankings. Do NOT use this to check your own rank if you already know your codename — use get_operator instead for a single-operator profile with per-window breakdowns. After calling this, follow up with get_operator to get detailed metrics for any operator of interest.",
   annotations: { title: "Get leaderboard", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
   inputSchema: {
     type: "object",

package/tools/get-operator.mjs

@@ -7,7 +7,7 @@ import { OPERATOR_OUTPUT, ANNOTATIONS } from "./_schemas.mjs";
 export const TOOL_DEF = {
   name: "get_operator",
   description:
-    "Fetches one operator's live profile from the SigRank board by their codename. Reads the operator's current submission data from signalaf.com and returns their detailed metrics: yield (Υ), leverage ratio (Cr/I), velocity (O/I), class tier (one of the 8 dev10x tiers: TRANSMITTER / ARCH+ / ARCH / POWER / BASE / SEEKER / REFINER / IGNITER), rank position (integer, 1-based), and per-window breakdowns for each time range (7d, 30d, 90d, all-time) with the four canonical pillars (input, output, cacheCreate, cacheRead) per window. Returns an error if the codename is not found on the board. Use this to look up any operator who has submitted to the board — codenames are public and visible on the leaderboard. Do NOT use this to browse all operators — use get_leaderboard for that. After calling this, you can use simulate_change to model what would happen if the operator adjusted their token mix.",
+    "Fetches one operator's live profile from the SigRank board by their codename. Reads the operator's current submission data from signalaf.com and returns their detailed metrics: yield (Υ), leverage ratio (Cr/I), velocity (O/I), class tier (one of 24 experience stages: 8 tiers × 3 sub-stages, e.g. ARCH+ I, REFINER II, IGNITER III), rank position (integer, 1-based), and per-window breakdowns for each time range (7d, 30d, 90d, all-time) with the four canonical pillars (input, output, cacheCreate, cacheRead) per window. Returns an error if the codename is not found on the board. Use this to look up any operator who has submitted to the board — codenames are public and visible on the leaderboard. Do NOT use this to browse all operators — use get_leaderboard for that. After calling this, you can use simulate_change to model what would happen if the operator adjusted their token mix.",
   annotations: { title: "Get operator profile", ...ANNOTATIONS.readOnlyHint, ...ANNOTATIONS.openWorldHint },
   inputSchema: {
     type: "object",

package/tools/rank-paste.mjs

@@ -10,7 +10,7 @@ import { MAX_INPUT, withParseWarnings } from "./_helpers.mjs";
 export const TOOL_DEF = {
   name: "rank_paste",
   description:
-    'Computes the SigRank yield cascade from a paste of token counts. Parses the input, runs the full cascade math locally (no network calls), and returns: yield (Υ, the headline efficiency metric, Υ = Cache Reads × Output / Input²), snr (signal-to-noise ratio), leverage (Cr/I = cache reads divided by input), velocity (O/I = output divided by input), dev10x (10xDEV score), class (operator class tier — the 8-tier dev10x taxonomy: TRANSMITTER / ARCH+ / ARCH / POWER / BASE / SEEKER / REFINER / IGNITER, or UNCLASSED for empty input), mode (detected working mode), and a deterministic prose "card" summarizing the result in plain English. Accepts two input formats: (1) JSON object {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} or (2) four whitespace-separated numbers in order: input output cacheCreate cacheRead. Returns an error if the input is malformed or has negative values. Use this for a quick one-off ranking without submitting to the board. Do NOT use this to submit your score — use submit_paste instead, which both ranks and publishes. Do NOT use this if you want to rank all four time windows at once — use rank_windows for that. After calling this, use submit_paste to publish the result if you want to appear on the leaderboard.',
+    'Computes the SigRank yield cascade from a paste of token counts. Parses the input, runs the full cascade math locally (no network calls), and returns: yield (Υ, the headline efficiency metric, Υ = Cache Reads × Output / Input²), snr (signal-to-noise ratio), leverage (Cr/I = cache reads divided by input), velocity (O/I = output divided by input), dev10x (10xDEV score), class (operator experience stage — 24 stages = 8 tiers × 3 sub-stages I/II/III, e.g. ARCH+ I, REFINER II, IGNITER III, or UNCLASSED for empty input), mode (detected working mode), and a deterministic prose "card" summarizing the result in plain English. Accepts two input formats: (1) JSON object {"input":N,"output":N,"cacheCreate":N,"cacheRead":N} or (2) four whitespace-separated numbers in order: input output cacheCreate cacheRead. Returns an error if the input is malformed or has negative values. Use this for a quick one-off ranking without submitting to the board. Do NOT use this to submit your score — use submit_paste instead, which both ranks and publishes. Do NOT use this if you want to rank all four time windows at once — use rank_windows for that. After calling this, use submit_paste to publish the result if you want to appear on the leaderboard.',
   annotations: {
     title: "Rank a paste",
     ...ANNOTATIONS.readOnlyHint,

package/tools/self-improve.mjs

@@ -159,7 +159,7 @@ export async function handleSelfImprove(args, ctx) {
     diagnosis.push({
       metric: "cache_leverage",
       severity: "critical",
-      finding: `Cache leverage is ${leverage}× — TRANSMITTER-class operators hit 200×+.`,
+      finding: `Cache leverage is ${leverage}× — top-tier operators hit 200×+.`,
       recommendation:
         "Increase context reuse: load prior session context, use longer threads.",
     });