sigrank 0.15.5 → 0.16.1

package/badges.mjs

@@ -0,0 +1,264 @@
+/**
+ * badges.mjs — pure badge computation for the Cascade Report System.
+ *
+ * 8 launch badges. Pure functions — take history + current pillars, return
+ * badge collection + progress. No deps, no transport, no network.
+ *
+ * Badge types:
+ *   Permanent — once earned, always earned (First Spark, Cascade Engine, etc.)
+ *   Current   — must be maintained (Cascade Streak, Top 10)
+ *
+ * Badge states:
+ *   earned     — condition met, badge is in the collection
+ *   in_progress — condition not yet met, but progress is trackable
+ *   locked     — condition not met, no progress to show (not returned)
+ */
+
+/**
+ * Compute all 8 launch badges.
+ *
+ * @param {object} params
+ * @param {object} params.pillars — current { input, output, cacheCreate, cacheRead }
+ * @param {object} params.cascade — current cascade result (from cascade())
+ * @param {array}  params.history — array of daily snapshots { date, mode, yield, pillars }
+ * @param {boolean} params.isVerified — whether the operator submitted via signed agent
+ * @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);
+
+  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");
+  } 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×`,
+    });
+  }
+
+  // 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");
+  } 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×`,
+    });
+  }
+
+  // 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");
+  } 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×`,
+    });
+  }
+
+  // 4. Foundation — 3 completed BUILD→MAINTAIN arcs
+  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");
+  } else {
+    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);
+  if (phoenixCount >= 5) {
+    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`,
+    });
+  }
+
+  // 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");
+  }
+  // No in-progress for verified — it's binary
+
+  // 7. Cascade Streak 🔥 — 7 consecutive days MAINTAIN (current badge)
+  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");
+  } else {
+    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");
+  }
+  // No in-progress for top 10 — it's a live position, not a progress badge
+
+  return {
+    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;
+}
+
+/**
+ * Count completed BUILD→MAINTAIN arcs in 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;
+  for (const h of history) {
+    if (h.mode === "BUILD") {
+      wasBuild = true;
+    } else if (h.mode === "MAINTAIN" && wasBuild) {
+      arcs++;
+      wasBuild = false;
+    }
+  }
+  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;
+  for (let idx = 1; idx < history.length; idx++) {
+    if (
+      history[idx].mode === "MAINTAIN" &&
+      history[idx - 1].mode !== "MAINTAIN"
+    ) {
+      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;
+  for (let idx = history.length - 1; idx >= 0; idx--) {
+    if (history[idx].mode === "MAINTAIN") {
+      streak++;
+    } else {
+      break;
+    }
+  }
+  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 = {
@@ -57,22 +62,99 @@ export function cascade({ input, output, cacheCreate, cacheRead }) {
     velocity: round(velocity, 3),
     dev10x: round(dev10x, 2),
     class: classify(yield_, dev10x),
-  }
-  if (warnings.length > 0) result.warnings = warnings
-  return result
+    mode: detectMode({ input: i, output: o, cacheCreate: cw, cacheRead: cr }),
+  };
+  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";
+}
+
+/**
+ * detectMode — classify an operator's current working mode from 4 token pillars.
+ *
+ * Pure ratio math, first-match-wins (same pattern as classify() — descending
+ * cuts preserve edge semantics). MAINTAIN checked first (high leverage is
+ * strongest signal), then DEBUG (low velocity is distinctive), then EDIT,
+ * then BUILD as fallback.
+ *
+ * Modes:
+ *   BUILD    — high input, low/zero cacheRead, output rising (greenfield)
+ *   EDIT     — high input, low cacheRead, high output (polishing)
+ *   DEBUG    — high input, low output, low cacheRead (investigating)
+ *   MAINTAIN — low input, high cacheRead, high output (compounding)
+ *   IDLE     — near-zero tokens (not working)
+ *
+ * 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;
+
+  // IDLE: near-zero tokens
+  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;
+
+  // 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 };
+
+  // DEBUG: low velocity + high input share (reading, not producing)
+  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 };
+
+  // DEBUG (secondary): high input share + low velocity
+  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 };
+}
+
+/**
+ * Expected yield per mode — global defaults used before personal baselines
+ * exist (needs 7+ days of history). Used by the quality score computation.
+ */
+export const MODE_EXPECTED_YIELD = {
+  BUILD: 15,
+  EDIT: 45,
+  DEBUG: 10,
+  MAINTAIN: 5000,
+  IDLE: 0,
+};
+
+/**
+ * qualityScore — actual yield relative to mode expectation.
+ * Fixes the "debug is bad" problem: a DEBUG session at 80% quality is good.
+ * 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;
 }
 
 /**
@@ -90,54 +172,103 @@ export function classify(yieldVal, dev10x) {
  *     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.",
+  );
 }