sigrank 0.16.0 → 0.16.1

package/badges.mjs

@@ -25,92 +25,190 @@
  * @param {number|null} params.rank — current leaderboard rank (null if not ranked)
  * @returns {object} { earned_this_week, in_progress, collection }
  */
-export function computeBadges({ pillars, cascade: cas, history = [], isVerified = false, rank = null }) {
-  const cr = Number(pillars?.cacheRead || 0)
-  const i = Number(pillars?.input || 0)
-  const leverage = cas?.leverage ?? (i > 0 ? cr / i : 0)
+export function computeBadges({
+  pillars,
+  cascade: cas,
+  history = [],
+  isVerified = false,
+  rank = null,
+}) {
+  const cr = Number(pillars?.cacheRead || 0);
+  const i = Number(pillars?.input || 0);
+  const leverage = cas?.leverage ?? (i > 0 ? cr / i : 0);
 
-  const earned = []
-  const inProgress = []
-  const collection = []
+  const earned = [];
+  const inProgress = [];
+  const collection = [];
 
   // 1. First Spark — cacheRead > input (1× leverage)
   if (leverage > 1) {
-    earned.push({ id: 'first_spark', label: 'First Spark', icon: '◈', condition: '1× cache leverage', date_earned: _latestDate(history) })
-    collection.push('first_spark')
+    earned.push({
+      id: "first_spark",
+      label: "First Spark",
+      icon: "◈",
+      condition: "1× cache leverage",
+      date_earned: _latestDate(history),
+    });
+    collection.push("first_spark");
   } else if (cr > 0) {
-    inProgress.push({ id: 'first_spark', label: 'First Spark', icon: '◈', progress: Math.min(leverage, 1), target: 1, display: `${leverage.toFixed(1)}× / 1×` })
+    inProgress.push({
+      id: "first_spark",
+      label: "First Spark",
+      icon: "◈",
+      progress: Math.min(leverage, 1),
+      target: 1,
+      display: `${leverage.toFixed(1)}× / 1×`,
+    });
   }
 
   // 2. Cascade Engine — cacheRead > 10× input
   if (leverage > 10) {
-    earned.push({ id: 'cascade_engine', label: 'Cascade Engine', icon: '⚡', condition: '10× cache leverage', date_earned: _latestDate(history) })
-    collection.push('cascade_engine')
+    earned.push({
+      id: "cascade_engine",
+      label: "Cascade Engine",
+      icon: "⚡",
+      condition: "10× cache leverage",
+      date_earned: _latestDate(history),
+    });
+    collection.push("cascade_engine");
   } else if (leverage > 1) {
-    inProgress.push({ id: 'cascade_engine', label: 'Cascade Engine', icon: '⚡', progress: Math.min(leverage, 10), target: 10, display: `${leverage.toFixed(1)}× / 10×` })
+    inProgress.push({
+      id: "cascade_engine",
+      label: "Cascade Engine",
+      icon: "⚡",
+      progress: Math.min(leverage, 10),
+      target: 10,
+      display: `${leverage.toFixed(1)}× / 10×`,
+    });
   }
 
   // 3. Chain Reaction — cacheRead > 100× input
   if (leverage > 100) {
-    earned.push({ id: 'chain_reaction', label: 'Chain Reaction', icon: '⚡', condition: '100× cache leverage', date_earned: _latestDate(history) })
-    collection.push('chain_reaction')
+    earned.push({
+      id: "chain_reaction",
+      label: "Chain Reaction",
+      icon: "⚡",
+      condition: "100× cache leverage",
+      date_earned: _latestDate(history),
+    });
+    collection.push("chain_reaction");
   } else if (leverage > 10) {
-    inProgress.push({ id: 'chain_reaction', label: 'Chain Reaction', icon: '⚡', progress: Math.min(leverage, 100), target: 100, display: `${leverage.toFixed(1)}× / 100×` })
+    inProgress.push({
+      id: "chain_reaction",
+      label: "Chain Reaction",
+      icon: "⚡",
+      progress: Math.min(leverage, 100),
+      target: 100,
+      display: `${leverage.toFixed(1)}× / 100×`,
+    });
   }
 
   // 4. Foundation — 3 completed BUILD→MAINTAIN arcs
-  const arcs = _countBuildMaintainArcs(history)
+  const arcs = _countBuildMaintainArcs(history);
   if (arcs >= 3) {
-    earned.push({ id: 'foundation', label: 'Foundation', icon: '🏗️', condition: '3 BUILD→MAINTAIN arcs', date_earned: _latestDate(history) })
-    collection.push('foundation')
+    earned.push({
+      id: "foundation",
+      label: "Foundation",
+      icon: "🏗️",
+      condition: "3 BUILD→MAINTAIN arcs",
+      date_earned: _latestDate(history),
+    });
+    collection.push("foundation");
   } else {
-    inProgress.push({ id: 'foundation', label: 'Foundation', icon: '🏗️', progress: arcs, target: 3, display: `${arcs}/3 arcs` })
+    inProgress.push({
+      id: "foundation",
+      label: "Foundation",
+      icon: "🏗️",
+      progress: arcs,
+      target: 3,
+      display: `${arcs}/3 arcs`,
+    });
   }
 
   // 5. Phoenix — returned to MAINTAIN within 1 day of disruption, 5×
-  const phoenixCount = _countPhoenixReturns(history)
+  const phoenixCount = _countPhoenixReturns(history);
   if (phoenixCount >= 5) {
-    earned.push({ id: 'phoenix', label: 'Phoenix', icon: '🔥', condition: '5× MAINTAIN recovery within 1 day', date_earned: _latestDate(history) })
-    collection.push('phoenix')
+    earned.push({
+      id: "phoenix",
+      label: "Phoenix",
+      icon: "🔥",
+      condition: "5× MAINTAIN recovery within 1 day",
+      date_earned: _latestDate(history),
+    });
+    collection.push("phoenix");
   } else {
-    inProgress.push({ id: 'phoenix', label: 'Phoenix', icon: '🔥', progress: phoenixCount, target: 5, display: `${phoenixCount}/5 recoveries` })
+    inProgress.push({
+      id: "phoenix",
+      label: "Phoenix",
+      icon: "🔥",
+      progress: phoenixCount,
+      target: 5,
+      display: `${phoenixCount}/5 recoveries`,
+    });
   }
 
   // 6. Verified — submitted via signed agent
   if (isVerified) {
-    earned.push({ id: 'verified', label: 'Verified', icon: '✓', condition: 'Submitted via signed agent', date_earned: _latestDate(history) })
-    collection.push('verified')
+    earned.push({
+      id: "verified",
+      label: "Verified",
+      icon: "✓",
+      condition: "Submitted via signed agent",
+      date_earned: _latestDate(history),
+    });
+    collection.push("verified");
   }
   // No in-progress for verified — it's binary
 
   // 7. Cascade Streak 🔥 — 7 consecutive days MAINTAIN (current badge)
-  const streak = _countMaintainStreak(history)
+  const streak = _countMaintainStreak(history);
   if (streak >= 7) {
-    earned.push({ id: 'cascade_streak', label: 'Cascade Streak', icon: '🔥', condition: '7 consecutive days MAINTAIN', date_earned: _latestDate(history), current: true })
-    collection.push('cascade_streak')
+    earned.push({
+      id: "cascade_streak",
+      label: "Cascade Streak",
+      icon: "🔥",
+      condition: "7 consecutive days MAINTAIN",
+      date_earned: _latestDate(history),
+      current: true,
+    });
+    collection.push("cascade_streak");
   } else {
-    inProgress.push({ id: 'cascade_streak', label: 'Cascade Streak', icon: '🔥', progress: streak, target: 7, display: `${streak}/7 days` })
+    inProgress.push({
+      id: "cascade_streak",
+      label: "Cascade Streak",
+      icon: "🔥",
+      progress: streak,
+      target: 7,
+      display: `${streak}/7 days`,
+    });
   }
 
   // 8. Top 10 🏆 — currently in top 10 (server-side, but we include it if rank is provided)
   if (rank !== null && rank <= 10) {
-    earned.push({ id: 'top_10', label: 'Top 10', icon: '🏆', condition: `Currently #${rank}`, date_earned: _latestDate(history), current: true })
-    collection.push('top_10')
+    earned.push({
+      id: "top_10",
+      label: "Top 10",
+      icon: "🏆",
+      condition: `Currently #${rank}`,
+      date_earned: _latestDate(history),
+      current: true,
+    });
+    collection.push("top_10");
   }
   // No in-progress for top 10 — it's a live position, not a progress badge
 
   return {
-    earned_this_week: earned.map(b => b.id),
+    earned_this_week: earned.map((b) => b.id),
     in_progress: inProgress,
     collection,
-  }
+  };
 }
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function _latestDate(history) {
-  if (!history || history.length === 0) return null
-  return history[history.length - 1]?.date || null
+  if (!history || history.length === 0) return null;
+  return history[history.length - 1]?.date || null;
 }
 
 /**
@@ -118,46 +216,49 @@ function _latestDate(history) {
  * An arc = a BUILD phase followed by a MAINTAIN phase.
  */
 function _countBuildMaintainArcs(history) {
-  if (!history || history.length < 2) return 0
-  let arcs = 0
-  let wasBuild = false
+  if (!history || history.length < 2) return 0;
+  let arcs = 0;
+  let wasBuild = false;
   for (const h of history) {
-    if (h.mode === 'BUILD') {
-      wasBuild = true
-    } else if (h.mode === 'MAINTAIN' && wasBuild) {
-      arcs++
-      wasBuild = false
+    if (h.mode === "BUILD") {
+      wasBuild = true;
+    } else if (h.mode === "MAINTAIN" && wasBuild) {
+      arcs++;
+      wasBuild = false;
     }
   }
-  return arcs
+  return arcs;
 }
 
 /**
  * Count Phoenix returns — MAINTAIN within 1 day of a non-MAINTAIN day.
  */
 function _countPhoenixReturns(history) {
-  if (!history || history.length < 2) return 0
-  let count = 0
+  if (!history || history.length < 2) return 0;
+  let count = 0;
   for (let idx = 1; idx < history.length; idx++) {
-    if (history[idx].mode === 'MAINTAIN' && history[idx - 1].mode !== 'MAINTAIN') {
-      count++
+    if (
+      history[idx].mode === "MAINTAIN" &&
+      history[idx - 1].mode !== "MAINTAIN"
+    ) {
+      count++;
     }
   }
-  return count
+  return count;
 }
 
 /**
  * Count current consecutive MAINTAIN days (ending at the last entry).
  */
 function _countMaintainStreak(history) {
-  if (!history || history.length === 0) return 0
-  let streak = 0
+  if (!history || history.length === 0) return 0;
+  let streak = 0;
   for (let idx = history.length - 1; idx >= 0; idx--) {
-    if (history[idx].mode === 'MAINTAIN') {
-      streak++
+    if (history[idx].mode === "MAINTAIN") {
+      streak++;
     } else {
-      break
+      break;
     }
   }
-  return streak
+  return streak;
 }

package/cascade.mjs

@@ -13,40 +13,45 @@
  *     Callers that require a fully-formed result should check `warnings.length === 0`.
  */
 
-export const round = (n, d) => (Number.isFinite(n) ? Number(n.toFixed(d)) : null)
+export const round = (n, d) =>
+  Number.isFinite(n) ? Number(n.toFixed(d)) : null;
 
 /** The four raw token pillars → the cascade. */
 export function cascade({ input, output, cacheCreate, cacheRead }) {
-  const i = Number(input), o = Number(output), cw = Number(cacheCreate), cr = Number(cacheRead)
-  const total = i + o + cw + cr
-  const warnings = []
+  const i = Number(input),
+    o = Number(output),
+    cw = Number(cacheCreate),
+    cr = Number(cacheRead);
+  const total = i + o + cw + cr;
+  const warnings = [];
 
   // SNR: undefined when both i and o are 0 (empty session)
-  const snrDenom = i + o
-  const snr = snrDenom > 0 ? o / snrDenom : null
-  if (snr === null) warnings.push('snr_undefined: input+output=0')
+  const snrDenom = i + o;
+  const snr = snrDenom > 0 ? o / snrDenom : null;
+  if (snr === null) warnings.push("snr_undefined: input+output=0");
 
   // velocity: undefined when i=0 (no fresh input — pure cache-only session)
-  const velocity = i > 0 ? o / i : null
-  if (velocity === null) warnings.push('velocity_undefined: input=0')
+  const velocity = i > 0 ? o / i : null;
+  if (velocity === null) warnings.push("velocity_undefined: input=0");
 
   // leverage: undefined when i=0
-  const leverage = i > 0 ? cr / i : null
-  if (leverage === null) warnings.push('leverage_undefined: input=0')
+  const leverage = i > 0 ? cr / i : null;
+  if (leverage === null) warnings.push("leverage_undefined: input=0");
 
   // Υ = leverage × velocity = (Cr·O)/I² — null when either component is null
-  const yield_ = leverage !== null && velocity !== null ? leverage * velocity : null
-  if (yield_ === null && !warnings.some((w) => w.startsWith('yield')))
-    warnings.push('yield_undefined: requires input>0')
+  const yield_ =
+    leverage !== null && velocity !== null ? leverage * velocity : null;
+  if (yield_ === null && !warnings.some((w) => w.startsWith("yield")))
+    warnings.push("yield_undefined: requires input>0");
 
   // dev10x = log10(Cr/I) — collapses when cw=0 (no cache commits) or i=0 or cr=0.
   // narrate.mjs already has a nonCompounding branch for this case; we return null
   // explicitly so the branch triggers correctly (vs -Infinity on log10(0)).
-  let dev10x = null
+  let dev10x = null;
   if (i > 0 && o > 0 && cw > 0 && cr > 0) {
-    dev10x = Math.log10((o / i) * (cw / o) * (cr / cw)) // = log10(Cr/I)
+    dev10x = Math.log10((o / i) * (cw / o) * (cr / cw)); // = log10(Cr/I)
   } else {
-    warnings.push('dev10x_undefined: requires all four pillars > 0')
+    warnings.push("dev10x_undefined: requires all four pillars > 0");
   }
 
   const result = {
@@ -58,22 +63,22 @@ export function cascade({ input, output, cacheCreate, cacheRead }) {
     dev10x: round(dev10x, 2),
     class: classify(yield_, dev10x),
     mode: detectMode({ input: i, output: o, cacheCreate: cw, cacheRead: cr }),
-  }
-  if (warnings.length > 0) result.warnings = warnings
-  return result
+  };
+  if (warnings.length > 0) result.warnings = warnings;
+  return result;
 }
 
 /** 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) {
-  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'
+  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";
 }
 
 /**
@@ -94,31 +99,39 @@ export function classify(yieldVal, dev10x) {
  * Returns { mode, confidence }.
  */
 export function detectMode({ input, output, cacheCreate, cacheRead }) {
-  const i = Number(input), o = Number(output), cw = Number(cacheCreate), cr = Number(cacheRead)
-  const total = i + o + cw + cr
+  const i = Number(input),
+    o = Number(output),
+    cw = Number(cacheCreate),
+    cr = Number(cacheRead);
+  const total = i + o + cw + cr;
 
   // IDLE: near-zero tokens
-  if (total < 1000) return { mode: 'IDLE', confidence: 1.0 }
+  if (total < 1000) return { mode: "IDLE", confidence: 1.0 };
 
-  const leverage    = i > 0 ? cr / i : 0
-  const velocity    = i > 0 ? o / i : 0
-  const input_share = total > 0 ? i / total : 0
+  const leverage = i > 0 ? cr / i : 0;
+  const velocity = i > 0 ? o / i : 0;
+  const input_share = total > 0 ? i / total : 0;
 
   // MAINTAIN: high leverage + high velocity (the cascade is compounding)
-  if (leverage > 10 && velocity > 1)  return { mode: 'MAINTAIN', confidence: 0.9 }
-  if (leverage > 3  && velocity > 0.5) return { mode: 'MAINTAIN', confidence: 0.7 }
+  if (leverage > 10 && velocity > 1)
+    return { mode: "MAINTAIN", confidence: 0.9 };
+  if (leverage > 3 && velocity > 0.5)
+    return { mode: "MAINTAIN", confidence: 0.7 };
 
   // DEBUG: low velocity + high input share (reading, not producing)
-  if (velocity < 0.3 && input_share > 0.5) return { mode: 'DEBUG', confidence: 0.8 }
+  if (velocity < 0.3 && input_share > 0.5)
+    return { mode: "DEBUG", confidence: 0.8 };
 
   // EDIT: high input share + high velocity (fresh input but producing)
-  if (input_share > 0.4 && velocity > 0.5) return { mode: 'EDIT', confidence: 0.7 }
+  if (input_share > 0.4 && velocity > 0.5)
+    return { mode: "EDIT", confidence: 0.7 };
 
   // DEBUG (secondary): high input share + low velocity
-  if (input_share > 0.4 && velocity < 0.5) return { mode: 'DEBUG', confidence: 0.6 }
+  if (input_share > 0.4 && velocity < 0.5)
+    return { mode: "DEBUG", confidence: 0.6 };
 
   // BUILD: fallback (high input, no cache reuse yet)
-  return { mode: 'BUILD', confidence: 0.6 }
+  return { mode: "BUILD", confidence: 0.6 };
 }
 
 /**
@@ -131,7 +144,7 @@ export const MODE_EXPECTED_YIELD = {
   DEBUG: 10,
   MAINTAIN: 5000,
   IDLE: 0,
-}
+};
 
 /**
  * qualityScore — actual yield relative to mode expectation.
@@ -139,9 +152,9 @@ export const MODE_EXPECTED_YIELD = {
  * Returns a number 0+ (can exceed 1.0 if outperforming the expected yield).
  */
 export function qualityScore(actualYield, mode) {
-  const expected = MODE_EXPECTED_YIELD[mode] ?? 1
-  if (expected === 0) return actualYield === 0 ? 1.0 : 0
-  return actualYield / expected
+  const expected = MODE_EXPECTED_YIELD[mode] ?? 1;
+  if (expected === 0) return actualYield === 0 ? 1.0 : 0;
+  return actualYield / expected;
 }
 
 /**
@@ -159,54 +172,103 @@ export function qualityScore(actualYield, mode) {
  *     something looks suspicious we surface it in `_parseWarnings` on the returned object.
  */
 export function parsePillars(text) {
-  const t = String(text || '').trim()
-  const pw = [] // parse warnings to attach
+  const t = String(text || "").trim();
+  const pw = []; // parse warnings to attach
 
   // ── JSON path ──────────────────────────────────────────────────────────────
   try {
-    const j = JSON.parse(t)
-    if (j && typeof j === 'object' && !Array.isArray(j)) {
-      const g = (...keys) => { for (const k of keys) if (j[k] != null) return j[k]; return null }
-      const input      = g('input', 'tokens_input_fresh', 'inputTokens', 'input_tokens')
-      const output     = g('output', 'tokens_output', 'outputTokens', 'output_tokens')
-      const cacheCreate = g('cacheCreate', 'tokens_cache_creation', 'cache_creation_tokens')
-      const cacheRead  = g('cacheRead', 'tokens_cache_read', 'cache_read_tokens')
+    const j = JSON.parse(t);
+    if (j && typeof j === "object" && !Array.isArray(j)) {
+      const g = (...keys) => {
+        for (const k of keys) if (j[k] != null) return j[k];
+        return null;
+      };
+      const input = g(
+        "input",
+        "tokens_input_fresh",
+        "inputTokens",
+        "input_tokens",
+      );
+      const output = g(
+        "output",
+        "tokens_output",
+        "outputTokens",
+        "output_tokens",
+      );
+      const cacheCreate = g(
+        "cacheCreate",
+        "tokens_cache_creation",
+        "cache_creation_tokens",
+      );
+      const cacheRead = g(
+        "cacheRead",
+        "tokens_cache_read",
+        "cache_read_tokens",
+      );
       if ([input, output, cacheCreate, cacheRead].every((v) => v != null)) {
         const pillars = {
           input: Number(input),
           output: Number(output),
           cacheCreate: Number(cacheCreate),
           cacheRead: Number(cacheRead),
-        }
-        if ([pillars.input, pillars.output, pillars.cacheCreate, pillars.cacheRead].some((v) => !Number.isFinite(v)))
-          throw new Error('Non-numeric pillar value in JSON (got string or non-finite number).')
-        if ([pillars.input, pillars.output, pillars.cacheCreate, pillars.cacheRead].some((v) => v < 0))
-          pw.push('negative_pillar: one or more pillars is negative — may be a data error')
-        if (pw.length > 0) pillars._parseWarnings = pw
-        return pillars
+        };
+        if (
+          [
+            pillars.input,
+            pillars.output,
+            pillars.cacheCreate,
+            pillars.cacheRead,
+          ].some((v) => !Number.isFinite(v))
+        )
+          throw new Error(
+            "Non-numeric pillar value in JSON (got string or non-finite number).",
+          );
+        if (
+          [
+            pillars.input,
+            pillars.output,
+            pillars.cacheCreate,
+            pillars.cacheRead,
+          ].some((v) => v < 0)
+        )
+          pw.push(
+            "negative_pillar: one or more pillars is negative — may be a data error",
+          );
+        if (pw.length > 0) pillars._parseWarnings = pw;
+        return pillars;
       }
     }
   } catch (e) {
     // JSON.parse syntax error — fall through to positional. Re-throw parse errors we raised ourselves.
-    if (e.message.startsWith('Non-numeric')) throw e
+    if (e.message.startsWith("Non-numeric")) throw e;
   }
 
   // ── Positional path ────────────────────────────────────────────────────────
   // Guard: if the text contains alphabetic words, the numeric extraction is unreliable.
   // We still attempt it (don't throw away the data) but flag it for review.
   if (/[a-zA-Z]/.test(t))
-    pw.push('positional_from_mixed_text: extracted numbers from text that contains alphabetic characters — verify these are the correct 4 pillars')
+    pw.push(
+      "positional_from_mixed_text: extracted numbers from text that contains alphabetic characters — verify these are the correct 4 pillars",
+    );
 
-  const nums = (t.match(/-?\d[\d,]*\.?\d*/g) || []).map((s) => Number(s.replace(/,/g, '')))
+  const nums = (t.match(/-?\d[\d,]*\.?\d*/g) || []).map((s) =>
+    Number(s.replace(/,/g, "")),
+  );
   if (nums.length >= 4) {
-    const [input, output, cacheCreate, cacheRead] = nums
+    const [input, output, cacheCreate, cacheRead] = nums;
     if (nums.length > 4)
-      pw.push(`positional_extra_numbers: found ${nums.length} numbers, using first 4 — inspect for positional order error`)
-    const pillars = { input, output, cacheCreate, cacheRead }
+      pw.push(
+        `positional_extra_numbers: found ${nums.length} numbers, using first 4 — inspect for positional order error`,
+      );
+    const pillars = { input, output, cacheCreate, cacheRead };
     if ([input, output, cacheCreate, cacheRead].some((v) => v < 0))
-      pw.push('negative_pillar: one or more pillars is negative — may be a data error')
-    if (pw.length > 0) pillars._parseWarnings = pw
-    return pillars
+      pw.push(
+        "negative_pillar: one or more pillars is negative — may be a data error",
+      );
+    if (pw.length > 0) pillars._parseWarnings = pw;
+    return pillars;
   }
-  throw new Error('Could not parse 4 token pillars (input, output, cacheCreate, cacheRead) from the input.')
+  throw new Error(
+    "Could not parse 4 token pillars (input, output, cacheCreate, cacheRead) from the input.",
+  );
 }