sigrank 0.0.175

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/banner.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="800" height="200" viewBox="0 0 800 200">
+  <rect width="800" height="200" rx="12" fill="#0a0805"/>
+  <rect x="0" y="0" width="800" height="3" rx="12" fill="#c4923a"/>
+  <text x="60" y="110" font-family="Georgia, serif" font-size="56" font-weight="700" fill="#e8b955">§ SigRank</text>
+  <text x="60" y="150" font-family="Helvetica, Arial, sans-serif" font-size="18" fill="#a89a7a">The AI operator leaderboard</text>
+  <text x="60" y="178" font-family="Helvetica, Arial, sans-serif" font-size="14" fill="#6b6354">signalaf.com</text>
+</svg>

package/cascade.mjs

@@ -0,0 +1,274 @@
+/**
+ * cascade.mjs — pure SigRank yield cascade (no deps, no transport).
+ * Mirrors sigrank-app/lib/ingest/bridge.ts computeCascadeMetrics() so rank_paste
+ * reproduces the canonical MO§ES Υ 18436.98 from its 4 raw token pillars.
+ * Paper-and-pencil math, open by design; proprietary threshold cuts stay server-side.
+ *
+ * Degenerate-input policy (hardened):
+ *   - Any pillar that collapses a denominator (i=0, o=0, cw=0, cr=0) returns null for
+ *     the affected metrics rather than Infinity/NaN.
+ *   - A `warnings[]` array is attached when any metric is null so callers can surface the
+ *     reason without silently corrupting downstream calculations.
+ *   - The cascade is NEVER thrown away — even partial results are useful for review/storage.
+ *     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;
+
+/** 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 = [];
+
+  // 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");
+
+  // 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");
+
+  // leverage: undefined when i=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");
+
+  // 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;
+  if (i > 0 && o > 0 && cw > 0 && cr > 0) {
+    dev10x = Math.log10((o / i) * (cw / o) * (cr / cw)); // = log10(Cr/I)
+  } else {
+    warnings.push("dev10x_undefined: requires all four pillars > 0");
+  }
+
+  const result = {
+    pillars: { input: i, output: o, cacheCreate: cw, cacheRead: cr, total },
+    yield: round(yield_, 2),
+    snr: round(snr, 4),
+    leverage: round(leverage, 1),
+    velocity: round(velocity, 3),
+    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;
+}
+
+/** 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";
+}
+
+/**
+ * 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;
+}
+
+/**
+ * Extract the 4 pillars from pasted text: JSON object OR 4 whitespace numbers.
+ *
+ * Hardened parse policy:
+ *   - JSON path: requires named keys and numeric values. Rejects strings/null.
+ *   - Positional path: requires the input to be ONLY numeric tokens (whitespace/commas
+ *     allowed as separators). If the text contains non-numeric words the positional
+ *     extractor attaches a `_parseWarnings` flag so downstream can route it to a review
+ *     channel instead of treating it as authoritative data.
+ *   - Negative values are accepted (not thrown away) but flagged — could be valid in
+ *     some edge-case accounting or a data error; the server is the authority on validity.
+ *   - We NEVER silently corrupt: if we can't parse 4 pillars we throw. If we parse but
+ *     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
+
+  // ── 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",
+      );
+      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;
+      }
+    }
+  } 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;
+  }
+
+  // ── 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",
+    );
+
+  const nums = (t.match(/-?\d[\d,]*\.?\d*/g) || []).map((s) =>
+    Number(s.replace(/,/g, "")),
+  );
+  if (nums.length >= 4) {
+    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 };
+    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;
+  }
+  throw new Error(
+    "Could not parse 4 token pillars (input, output, cacheCreate, cacheRead) from the input.",
+  );
+}