sigrank 0.18.5 → 1.0.1

package/tools/_peer-matching.mjs

@@ -0,0 +1,361 @@
+/**
+ * tools/_peer-matching.mjs — pure peer-discovery logic for discover_peers.
+ *
+ * Shared between _02_sigrank-mcp (operator's agent, uses enrolled identity)
+ * and _04_bestuser-router-mcp (marketing layer, takes codename arg). The
+ * canonical version lives here; _04 vendors a copy.
+ *
+ * All functions are pure — no network, no side effects. They operate on
+ * leaderboard entry objects as returned by the signalaf.com API:
+ *   { codename, class_tier, platform, yield_, leverage, velocity, snr,
+ *     input_tokens, output_tokens, cache_creation_tokens, cache_read_tokens,
+ *     rank, ... }
+ *
+ * Three categorization functions:
+ *   findMentors     — operators 1-2 class tiers above, ranked by cascade shape similarity
+ *   findPeers       — operators in the same class tier, ranked by yield proximity
+ *   findComplementary — operators whose strength maps to the operator's weakness
+ *
+ * Plus pillar delta computation: the specific token difference that explains
+ * the yield gap between an operator and a mentor.
+ */
+
+import { CLASS_TIERS, UNCLASSED, tierOf } from "../analytics/cascade.mjs";
+
+/**
+ * Class tier rank index (0 = ARCH+ top, 7 = IGNITER bottom, -1 = UNCLASSED).
+ * Used to determine who is "above" an operator in the experience ladder.
+ */
+export function tierRank(klass) {
+  const base = tierOf(klass);
+  if (base === UNCLASSED || base == null) return -1;
+  return CLASS_TIERS.indexOf(base);
+}
+
+/**
+ * Normalize a cascade shape into a 3D vector for similarity comparison.
+ * The three dimensions are the cascade ratios that define an operator's
+ * "shape" independent of scale:
+ *   - leverage (Cr/I): how much they reuse prior context
+ *   - velocity (O/I): how much output they get per input token
+ *   - snr (O/(I+O)): signal cleanliness
+ *
+ * Each is log-scaled and normalized to [0,1] so operators at different scales
+ * can be compared by shape, not absolute magnitude. An operator with 100x
+ * leverage and one with 1000x leverage have similar *shapes* — both are
+ * high-leverage operators, just at different scales.
+ */
+export function cascadeShape(op) {
+  const l = Number(op.leverage) || 0;
+  const v = Number(op.velocity) || 0;
+  const s = Number(op.snr) || 0;
+  // Log-scale, clamp to [0,1]. Log thresholds chosen so typical ranges map well:
+  //   leverage: 0-1000x → log1p(0)-log1p(1000) ≈ 0-6.9
+  //   velocity: 0-10x   → log1p(0)-log1p(10)   ≈ 0-2.4
+  //   snr:      0-1     → log1p(0)-log1p(1)    ≈ 0-0.69
+  const norm = (val, max) => Math.min(1, Math.log1p(Math.max(0, val)) / Math.log1p(max));
+  return [
+    norm(l, 1000),
+    norm(v, 10),
+    norm(s, 1),
+  ];
+}
+
+/**
+ * Euclidean distance between two cascade shapes, normalized to [0,1].
+ * 0 = identical shape, 1 = maximally different. Used to rank mentors:
+ * closer shape = "they were where you are but scaled up."
+ */
+export function shapeDistance(opA, opB) {
+  const a = cascadeShape(opA);
+  const b = cascadeShape(opB);
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    const d = a[i] - b[i];
+    sum += d * d;
+  }
+  return Math.sqrt(sum / a.length);
+}
+
+/**
+ * Similarity score = 1 - distance. Higher = more similar cascade shape.
+ */
+export function shapeSimilarity(opA, opB) {
+  return 1 - shapeDistance(opA, opB);
+}
+
+/**
+ * Compute the pillar delta between an operator and a mentor.
+ * Returns the specific token differences that explain the yield gap,
+ * expressed as both absolute tokens and multipliers.
+ *
+ *   { pillar, mentor_value, operator_value, multiplier, absolute_delta, explanation }
+ *
+ * The pillar with the largest yield impact is listed first. Since yield =
+ * (cacheRead × output) / input², the impact ranking is:
+ *   1. cache_read (linear multiplier in yield)
+ *   2. input (quadratic denominator — reducing input has squared impact)
+ *   3. output (linear multiplier in yield)
+ *   4. cache_create (enables future cache reads — indirect)
+ */
+export function pillarDelta(operator, mentor) {
+  const opI = Number(operator.input_tokens) || 0;
+  const opO = Number(operator.output_tokens) || 0;
+  const opCr = Number(operator.cache_read_tokens) || 0;
+  const opCw = Number(operator.cache_creation_tokens) || 0;
+
+  const mtI = Number(mentor.input_tokens) || 0;
+  const mtO = Number(mentor.output_tokens) || 0;
+  const mtCr = Number(mentor.cache_read_tokens) || 0;
+  const mtCw = Number(mentor.cache_creation_tokens) || 0;
+
+  const safeMult = (mt, op) => (op > 0 ? mt / op : mt > 0 ? Infinity : 1);
+  const fmtMult = (m) => (m === Infinity ? "∞" : `${m.toFixed(1)}×`);
+
+  const deltas = [
+    {
+      pillar: "cache_read",
+      mentor_value: mtCr,
+      operator_value: opCr,
+      multiplier: safeMult(mtCr, opCr),
+      absolute_delta: mtCr - opCr,
+      explanation:
+        opCr > 0
+          ? `${fmtMult(safeMult(mtCr, opCr))} your cache reads — the strongest yield multiplier`
+          : `You have no cache reads; mentor has ${mtCr.toLocaleString()} — this is the entire yield gap`,
+    },
+    {
+      pillar: "input",
+      mentor_value: mtI,
+      operator_value: opI,
+      multiplier: safeMult(mtI, opI),
+      absolute_delta: mtI - opI,
+      explanation:
+        mtI < opI
+          ? `${fmtMult(opI / mtI)} less input than you — input² is in the denominator, so leaner input has quadratic payoff`
+          : `${fmtMult(safeMult(mtI, opI))} your input — they use more fresh tokens but compensate with cache reuse`,
+    },
+    {
+      pillar: "output",
+      mentor_value: mtO,
+      operator_value: opO,
+      multiplier: safeMult(mtO, opO),
+      absolute_delta: mtO - opO,
+      explanation: `${fmtMult(safeMult(mtO, opO))} your output — linear yield multiplier`,
+    },
+    {
+      pillar: "cache_create",
+      mentor_value: mtCw,
+      operator_value: opCw,
+      multiplier: safeMult(mtCw, opCw),
+      absolute_delta: mtCw - opCw,
+      explanation:
+        opCw > 0
+          ? `${fmtMult(safeMult(mtCw, opCw))} your cache writes — enables future cache reads`
+          : `You have no cache writes; mentor has ${mtCw.toLocaleString()} — they're investing in future cache`,
+    },
+  ];
+
+  // Sort by yield impact: cache_read first (strongest), then input (quadratic),
+  // then output (linear), then cache_create (indirect).
+  const order = { cache_read: 0, input: 1, output: 2, cache_create: 3 };
+  deltas.sort((a, b) => order[a.pillar] - order[b.pillar]);
+
+  return deltas;
+}
+
+/**
+ * Find mentors: operators 1-2 class tiers above, ranked by cascade shape
+ * similarity. These are operators who were where you are and broke through.
+ *
+ * @param {object} operator — the operator's leaderboard entry
+ * @param {array} board — all leaderboard entries
+ * @param {object} opts — { platform: string|null, n: number }
+ * @returns {array} mentors sorted by similarity (descending)
+ */
+export function findMentors(operator, board, opts = {}) {
+  const n = Math.min(20, Math.max(1, opts.n ?? 5));
+  const myTier = tierRank(operator.class_tier || operator.class);
+  if (myTier < 0) return []; // UNCLASSED — no mentors
+
+  const myPlatform = operator.platform;
+
+  return board
+    .filter((op) => op.codename !== operator.codename)
+    .filter((op) => {
+      if (opts.platform && op.platform !== opts.platform) return false;
+      if (!opts.platform && myPlatform && op.platform !== myPlatform) return false;
+      return true;
+    })
+    .filter((op) => {
+      const theirTier = tierRank(op.class_tier || op.class);
+      // 1-2 tiers above (lower index = higher tier)
+      return theirTier >= 0 && theirTier < myTier && theirTier >= myTier - 2;
+    })
+    .map((op) => ({
+      ...op,
+      similarity_score: Math.round(shapeSimilarity(operator, op) * 100) / 100,
+      pillar_delta: pillarDelta(operator, op),
+    }))
+    .sort((a, b) => b.similarity_score - a.similarity_score)
+    .slice(0, n);
+}
+
+/**
+ * Find peers: operators in the same class tier (same base tier, any sub-stage),
+ * ranked by yield proximity. These are your direct competitors.
+ *
+ * @param {object} operator
+ * @param {array} board
+ * @param {object} opts
+ * @returns {array} peers sorted by yield proximity (ascending delta)
+ */
+export function findPeers(operator, board, opts = {}) {
+  const n = Math.min(20, Math.max(1, opts.n ?? 5));
+  const myTier = tierOf(operator.class_tier || operator.class);
+  if (myTier === UNCLASSED || myTier == null) return [];
+
+  const myPlatform = operator.platform;
+  const myYield = Number(operator.yield_) || 0;
+
+  return board
+    .filter((op) => op.codename !== operator.codename)
+    .filter((op) => {
+      if (opts.platform && op.platform !== opts.platform) return false;
+      if (!opts.platform && myPlatform && op.platform !== myPlatform) return false;
+      return true;
+    })
+    .filter((op) => tierOf(op.class_tier || op.class) === myTier)
+    .map((op) => ({
+      codename: op.codename,
+      class_tier: op.class_tier || op.class,
+      yield_: op.yield_,
+      leverage: op.leverage,
+      velocity: op.velocity,
+      platform: op.platform,
+      rank: op.rank,
+      yield_delta_from_you: Math.round((Number(op.yield_) || 0) - myYield),
+      shareable_url: op.codename
+        ? `${opts.apiBase || "https://signalaf.com"}/operator/${encodeURIComponent(op.codename)}`
+        : null,
+    }))
+    .sort((a, b) => Math.abs(a.yield_delta_from_you) - Math.abs(b.yield_delta_from_you))
+    .slice(0, n);
+}
+
+/**
+ * Find complementary operators: those whose strongest dimension is the
+ * operator's weakest. Surfaces operators whose strengths map to your gaps.
+ *
+ * Determines the operator's weakest cascade dimension (leverage, velocity, or
+ * snr) relative to the board, then finds operators who are strongest in that
+ * dimension.
+ *
+ * @param {object} operator
+ * @param {array} board
+ * @param {object} opts
+ * @returns {array} complementary operators with strength/weakness annotation
+ */
+export function findComplementary(operator, board, opts = {}) {
+  const n = Math.min(20, Math.max(1, opts.n ?? 5));
+  const myPlatform = operator.platform;
+
+  const filtered = board
+    .filter((op) => op.codename !== operator.codename)
+    .filter((op) => {
+      if (opts.platform && op.platform !== opts.platform) return false;
+      if (!opts.platform && myPlatform && op.platform !== myPlatform) return false;
+      return true;
+    });
+
+  if (filtered.length === 0) return [];
+
+  // Compute board averages for each dimension
+  const avg = (key) =>
+    filtered.reduce((s, op) => s + (Number(op[key]) || 0), 0) / filtered.length;
+
+  const avgLeverage = avg("leverage");
+  const avgVelocity = avg("velocity");
+  const avgSnr = avg("snr");
+
+  // Find the operator's weakest dimension (furthest below average)
+  const myLeverage = Number(operator.leverage) || 0;
+  const myVelocity = Number(operator.velocity) || 0;
+  const mySnr = Number(operator.snr) || 0;
+
+  const weaknesses = [
+    { dimension: "leverage", value: myLeverage, avg: avgLeverage, gap: avgLeverage - myLeverage },
+    { dimension: "velocity", value: myVelocity, avg: avgVelocity, gap: avgVelocity - myVelocity },
+    { dimension: "snr", value: mySnr, avg: avgSnr, gap: avgSnr - mySnr },
+  ].sort((a, b) => b.gap - a.gap); // largest gap first
+
+  const weakest = weaknesses[0];
+
+  // If the operator is above average in all dimensions, find the dimension
+  // where they're closest to average (their "relatively weakest")
+  const targetDimension = weakest.gap > 0 ? weakest.dimension : weaknesses[0].dimension;
+
+  // Find operators strongest in that dimension
+  return filtered
+    .map((op) => ({
+      codename: op.codename,
+      class_tier: op.class_tier || op.class,
+      yield_: op.yield_,
+      platform: op.platform,
+      rank: op.rank,
+      strength_dimension: targetDimension,
+      strength_value: Number(op[targetDimension]) || 0,
+      your_weakness: {
+        dimension: targetDimension,
+        your_value: Number(operator[targetDimension]) || 0,
+        board_average: Math.round(weakest.avg * 100) / 100,
+      },
+      shareable_url: op.codename
+        ? `${opts.apiBase || "https://signalaf.com"}/operator/${encodeURIComponent(op.codename)}`
+        : null,
+    }))
+    .sort((a, b) => b.strength_value - a.strength_value)
+    .slice(0, n);
+}
+
+/**
+ * Generate the summary line for discover_peers output.
+ */
+export function peerSummary(operator, mentors, peers, complementary) {
+  const klass = operator.class_tier || operator.class || UNCLASSED;
+  const platform = operator.platform || "all";
+  const parts = [];
+
+  parts.push(`You're ${klass} on ${platform}.`);
+
+  if (mentors.length > 0) {
+    const topMentor = mentors[0];
+    const topDelta = topMentor.pillar_delta[0];
+    parts.push(
+      `${mentors.length} mentor${mentors.length > 1 ? "s" : ""} found — operators whose cascade shape is closest to yours but 1-2 tiers higher.`,
+    );
+    if (topDelta) {
+      parts.push(`Key gap: ${topDelta.explanation.toLowerCase()}.`);
+    }
+  } else {
+    const myTier = tierRank(klass);
+    if (myTier === 0) {
+      parts.push("You're at the top tier (ARCH+) — you are the mentor.");
+    } else {
+      parts.push("No mentors found in the 1-2 tier range above you.");
+    }
+  }
+
+  if (peers.length > 0) {
+    parts.push(`${peers.length} direct peer${peers.length > 1 ? "s" : ""} in the ${tierOf(klass)} tier.`);
+  }
+
+  if (complementary.length > 0) {
+    const comp = complementary[0];
+    parts.push(
+      `Study ${comp.codename} for ${comp.strength_dimension} (${comp.strength_value.toFixed(1)} vs your ${(Number(operator[comp.strength_dimension]) || 0).toFixed(1)}).`,
+    );
+  }
+
+  return parts.join(" ");
+}

package/tools/_report.mjs

@@ -0,0 +1,262 @@
+/**
+ * tools/_report.mjs — cascade report blocks + self-improvement scope helpers.
+ *
+ * Used by submit_verified (per-window report payload) and self_improve
+ * (weekly/trend scope analysis).
+ */
+
+import { cascade, detectMode, qualityScore, MODE_EXPECTED_YIELD } from "../analytics/cascade.mjs";
+import { computeBadges } from "../badges.mjs";
+import { execFileAsync } from "./_helpers.mjs";
+
+/**
+ * Compute the cascade report block for a submission payload.
+ * Pure math — mode detection + badges + health score from the current pillars.
+ * The server stores this as-is (does NOT recompute modes).
+ * Weekly granularity is the privacy boundary — no daily modes in the report.
+ */
+export function _computeReportBlock(pillars) {
+  const cas = cascade(pillars);
+  const modeInfo = detectMode(pillars);
+  const badges = computeBadges({
+    pillars,
+    cascade: cas,
+    history: [], // no history available at submit time — badges computed from current pillars only
+    isVerified: true, // submit_verified is the signed agent path
+    rank: null,
+  });
+  return {
+    current_mode: modeInfo.mode,
+    mode_confidence: modeInfo.confidence,
+    mode_distribution: { [modeInfo.mode]: 1.0 }, // single-window submission
+    mode_weighted_yield: cas.yield ?? 0,
+    peak_yield: cas.yield ?? 0,
+    health_score: _healthScore(
+      [{ mode: modeInfo.mode, yield: cas.yield ?? 0 }],
+      cas.yield ?? 0,
+    ),
+    badges,
+  };
+}
+
+/** Pull daily rows from ccusage to build mode history. Returns array of { date, pillars, yield, mode }. */
+export async function _pullDailyRows(opts = {}) {
+  try {
+    const raw = await execFileAsync(
+      "ccusage",
+      ["claude", "daily", "--json"],
+      15000,
+    );
+    const rows = JSON.parse(raw)?.daily ?? JSON.parse(raw);
+    if (!Array.isArray(rows)) return [];
+    return rows
+      .map((r) => {
+        const pillars = {
+          input: r.inputTokens ?? r.input_tokens ?? 0,
+          output: r.outputTokens ?? r.output_tokens ?? 0,
+          cacheCreate: r.cacheCreationTokens ?? r.cache_create_tokens ?? 0,
+          cacheRead: r.cacheReadTokens ?? r.cache_read_tokens ?? 0,
+        };
+        const cas = cascade(pillars);
+        const mode = detectMode(pillars);
+        return {
+          date: r.date ?? r.day ?? null,
+          pillars,
+          yield: cas.yield ?? 0,
+          mode: mode.mode,
+          mode_confidence: mode.confidence,
+        };
+      })
+      .filter((r) => r.date);
+  } catch {
+    return [];
+  }
+}
+
+/** Compound daily rows into weekly snapshots. Each week = 7 days, starting Monday. */
+export function _compoundWeekly(dailyRows) {
+  if (!dailyRows || dailyRows.length === 0) return [];
+  // Group by ISO week (week starts Monday)
+  const weeks = new Map();
+  for (const row of dailyRows) {
+    const d = new Date(row.date);
+    const day = d.getDay() || 7; // Sunday=0 → 7
+    const monday = new Date(d);
+    monday.setDate(d.getDate() - day + 1);
+    const weekKey = monday.toISOString().slice(0, 10);
+    if (!weeks.has(weekKey)) {
+      weeks.set(weekKey, { weekStart: weekKey, days: [] });
+    }
+    weeks.get(weekKey).days.push(row);
+  }
+  // Compound each week
+  return Array.from(weeks.values())
+    .map((w) => {
+      const pillars = w.days.reduce(
+        (acc, d) => ({
+          input: acc.input + d.pillars.input,
+          output: acc.output + d.pillars.output,
+          cacheCreate: acc.cacheCreate + d.pillars.cacheCreate,
+          cacheRead: acc.cacheRead + d.pillars.cacheRead,
+        }),
+        { input: 0, output: 0, cacheCreate: 0, cacheRead: 0 },
+      );
+      const cas = cascade(pillars);
+      const mode = detectMode(pillars);
+      return {
+        weekStart: w.weekStart,
+        pillars,
+        yield: cas.yield ?? 0,
+        mode: mode.mode,
+        mode_confidence: mode.confidence,
+        dayCount: w.days.length,
+        dailyModes: w.days.map((d) => d.mode), // stays local — not in submitted report
+      };
+    })
+    .sort((a, b) => a.weekStart.localeCompare(b.weekStart));
+}
+
+/** Compute mode distribution from weekly snapshots (weekly granularity = privacy boundary). */
+export function _modeDistribution(weeklySnapshots) {
+  if (!weeklySnapshots || weeklySnapshots.length === 0) return {};
+  const counts = { BUILD: 0, EDIT: 0, DEBUG: 0, MAINTAIN: 0, IDLE: 0 };
+  for (const w of weeklySnapshots) {
+    counts[w.mode] = (counts[w.mode] || 0) + 1;
+  }
+  const total = weeklySnapshots.length;
+  const dist = {};
+  for (const [mode, count] of Object.entries(counts)) {
+    if (count > 0) dist[mode] = Math.round((count / total) * 100) / 100;
+  }
+  return dist;
+}
+
+/** Mode-weighted yield — average yield weighted by mode distribution. */
+export function _modeWeightedYield(weeklySnapshots) {
+  if (!weeklySnapshots || weeklySnapshots.length === 0) return 0;
+  const total = weeklySnapshots.length;
+  const sum = weeklySnapshots.reduce((acc, w) => acc + (w.yield || 0), 0);
+  return Math.round(sum / total);
+}
+
+/** Peak yield across all weekly snapshots. */
+export function _peakYield(weeklySnapshots) {
+  if (!weeklySnapshots || weeklySnapshots.length === 0) return 0;
+  return Math.max(...weeklySnapshots.map((w) => w.yield || 0));
+}
+
+/** Health score (0-100) — weighted composite of consistency, momentum, quality. */
+export function _healthScore(weeklySnapshots, modeWeightedYield) {
+  if (!weeklySnapshots || weeklySnapshots.length === 0) return 0;
+  // Simplified Phase 1 formula:
+  //  40% — consistency (how often in MAINTAIN)
+  //  30% — momentum (recent yield vs older yield)
+  //  30% — quality (mode-weighted yield relative to MAINTAIN expected)
+  const dist = _modeDistribution(weeklySnapshots);
+  const maintainShare = dist.MAINTAIN || 0;
+  const consistency = Math.min(maintainShare, 1) * 40;
+
+  // Momentum: compare last 3 weeks to first 3 weeks
+  const recent = weeklySnapshots.slice(-3);
+  const older = weeklySnapshots.slice(0, 3);
+  const recentAvg =
+    recent.reduce((a, w) => a + (w.yield || 0), 0) / (recent.length || 1);
+  const olderAvg =
+    older.reduce((a, w) => a + (w.yield || 0), 0) / (older.length || 1);
+  const momentumRatio = olderAvg > 0 ? recentAvg / olderAvg : 1;
+  const momentum = (Math.min(momentumRatio, 2) / 2) * 30;
+
+  // Quality: mode-weighted yield vs MAINTAIN expected (5000)
+  const quality = Math.min(modeWeightedYield / 5000, 1) * 30;
+
+  return Math.round(consistency + momentum + quality);
+}
+
+/** Yield for the last N days (from weekly snapshots — approximates by summing recent weeks). */
+export function _yieldForDays(weeklySnapshots, days) {
+  if (!weeklySnapshots || weeklySnapshots.length === 0) return 0;
+  const weeksNeeded = Math.ceil(days / 7);
+  const recent = weeklySnapshots.slice(-weeksNeeded);
+  if (recent.length === 0) return 0;
+  const sum = recent.reduce((a, w) => a + (w.yield || 0), 0);
+  return Math.round(sum / recent.length); // average weekly yield
+}
+
+/** Trajectory description from 7d/30d/90d yields. */
+export function _trajectory(y7, y30, y90) {
+  if (y90 === 0) return "insufficient_data";
+  const r7v30 = y30 > 0 ? y7 / y30 : 1;
+  const r30v90 = y90 > 0 ? y30 / y90 : 1;
+  if (r7v30 > 1.2 && r30v90 > 1.0) return "accelerating";
+  if (r7v30 > 1.2) return "recent_surge";
+  if (r7v30 < 0.8 && r30v90 < 0.8) return "declining";
+  if (r7v30 < 0.8) return "recent_dip";
+  if (r30v90 > 1.1) return "steady_growth";
+  return "stable";
+}
+
+/** Phase pattern description from mode distribution over time. */
+export function _phasePattern(weeklySnapshots) {
+  if (!weeklySnapshots || weeklySnapshots.length < 2)
+    return "insufficient_data";
+  const modes = weeklySnapshots.map((w) => w.mode);
+  const transitions = [];
+  for (let i = 1; i < modes.length; i++) {
+    if (modes[i] !== modes[i - 1]) {
+      transitions.push(`${modes[i - 1]}→${modes[i]}`);
+    }
+  }
+  if (transitions.length === 0) return `consistent_${modes[0].toLowerCase()}`;
+  // Check for smooth transitions (BUILD→MAINTAIN without DEBUG)
+  const smooth = transitions.every((t) => !t.includes("DEBUG"));
+  if (smooth && transitions.some((t) => t === "BUILD→MAINTAIN"))
+    return "smooth_ramp";
+  if (transitions.filter((t) => t.includes("DEBUG")).length > 2)
+    return "erratic";
+  return "cyclical";
+}
+
+/** Daily assessment string. */
+export function _dailyAssessment(mode, yieldVal, qualityScoreVal, expectedYield) {
+  const qsPct = Math.round(qualityScoreVal * 100);
+  if (mode === "IDLE")
+    return "You're idle — no significant token activity today.";
+  if (mode === "MAINTAIN") {
+    if (qualityScoreVal >= 0.5)
+      return `You're in MAINTAIN mode. Yield ${yieldVal} is ${qsPct}% of MAINTAIN norm. The cascade is compounding.`;
+    return `You're in MAINTAIN mode but yield ${yieldVal} is only ${qsPct}% of expected (${expectedYield}). You may be coasting — push for more output.`;
+  }
+  if (mode === "BUILD") {
+    if (qualityScoreVal >= 0.5)
+      return `You're in BUILD mode. Yield ${yieldVal} is ${qsPct}% of BUILD norm. Greenfield work — expected to be low.`;
+    return `You're in BUILD mode. Yield ${yieldVal} is ${qsPct}% of expected (${expectedYield}). Building is slow — keep going.`;
+  }
+  if (mode === "EDIT") {
+    if (qualityScoreVal >= 0.5)
+      return `You're in EDIT mode. Yield ${yieldVal} is ${qsPct}% of EDIT norm. Fresh input but producing — good.`;
+    return `You're in EDIT mode. Yield ${yieldVal} is ${qsPct}% of expected (${expectedYield}). Push for more output per input.`;
+  }
+  if (mode === "DEBUG") {
+    if (qualityScoreVal >= 0.5)
+      return `You're in DEBUG mode. Yield ${yieldVal} is ${qsPct}% of DEBUG norm. Investigating — yield is expected to be low.`;
+    return `You're in DEBUG mode. Yield ${yieldVal} is ${qsPct}% of expected (${expectedYield}). Debugging is slow — consider loading prior context.`;
+  }
+  return `Mode: ${mode}. Yield: ${yieldVal}. Quality: ${qsPct}%.`;
+}
+
+/** Daily advice string. */
+export function _dailyAdvice(mode, yieldVal, qs) {
+  if (mode === "MAINTAIN" && qs >= 0.5)
+    return "Keep the cascade going. Don't reset context — let it compound.";
+  if (mode === "MAINTAIN")
+    return "You're in MAINTAIN but underperforming. Push the agent for more output per turn.";
+  if (mode === "BUILD")
+    return "When you're done building, load prior context to transition to MAINTAIN. The cascade rewards reuse.";
+  if (mode === "EDIT")
+    return "You're producing but using fresh input. Try to reuse prior context to boost leverage.";
+  if (mode === "DEBUG")
+    return "When you're done debugging, load prior context to return to MAINTAIN. Don't let the debug phase drag on.";
+  if (mode === "IDLE")
+    return "No activity detected. Start a session to build your cascade.";
+  return "Keep working — the cascade will compound as you build context.";
+}