@iamoberlin/chorus 2.3.0 → 2.4.0

package/index.ts

@@ -644,6 +644,49 @@ const plugin = {
           console.log("");
         });
 
+      // ── Behavioral Sink Health (Universe 25) ──────────────────
+      program
+        .command("health")
+        .description("Behavioral sink health check (Universe 25 anti-collapse)")
+        .action(async () => {
+          const { getSinkHealthSummary } = await import("./src/behavioral-sink.js");
+          const health = getSinkHealthSummary();
+          console.log("");
+          console.log(health.healthy ? "🟢 CHORUS Health: HEALTHY" : "🔴 CHORUS Health: DEGRADED");
+          console.log("═".repeat(50));
+          console.log("");
+
+          if (Object.keys(health.choirHealth).length === 0) {
+            console.log("  No quality data yet. Run some choir cycles first.");
+          } else {
+            console.log("  Choir Quality (avg over last 10 runs):");
+            for (const [id, h] of Object.entries(health.choirHealth) as any) {
+              const bar = "█".repeat(Math.round(h.avgQuality / 5)) + "░".repeat(20 - Math.round(h.avgQuality / 5));
+              const trendIcon = h.trend === "improving" ? "📈" : h.trend === "declining" ? "📉" : "➡️";
+              const boAlert = h.beautifulOneCount > 0 ? ` 🪞×${h.beautifulOneCount}` : "";
+              console.log(`    ${id.padEnd(16)} [${bar}] ${h.avgQuality}  ${trendIcon}${boAlert}`);
+            }
+          }
+
+          if (health.starvingPurposes.length > 0) {
+            console.log("");
+            console.log("  🏚️ Starving Purposes:");
+            for (const p of health.starvingPurposes) {
+              console.log(`    - ${p}`);
+            }
+          }
+
+          if (health.recentIncidents.length > 0) {
+            console.log("");
+            console.log("  🪞 Recent Beautiful One Incidents:");
+            for (const i of health.recentIncidents) {
+              console.log(`    ${i.timestamp.slice(0, 16)} ${i.choirId} (score: ${i.score})`);
+            }
+          }
+
+          console.log("");
+        });
+
       // Daemon commands
       const daemonCmd = program.command("daemon").description("Autonomous attention daemon");
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@iamoberlin/chorus",
-  "version": "2.3.0",
-  "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement — with on-chain Prayer Chain (Solana)",
+  "version": "2.4.0",
+  "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement \u2014 with on-chain Prayer Chain (Solana)",
   "author": "Oberlin <iam@oberlin.ai>",
   "license": "MIT",
   "repository": {

package/src/behavioral-sink.ts

@@ -0,0 +1,434 @@
+/**
+ * CHORUS Behavioral Sink Prevention
+ *
+ * Inspired by John B. Calhoun's Universe 25 (1968-1972):
+ * A mouse utopia with unlimited resources collapsed not from scarcity,
+ * but from loss of purpose and structural role degradation.
+ *
+ * Three failure modes mapped to CHORUS:
+ *
+ * 1. BEAUTIFUL ONES — Mice that looked perfect but did nothing.
+ *    → Choirs producing verbose but vacuous output. Busy ≠ productive.
+ *
+ * 2. BEHAVIORAL SINK — Pathological behaviors spreading contagiously.
+ *    → Degraded illumination cascading through the choir hierarchy.
+ *
+ * 3. TERRITORIAL EXCLUSION — Dominant mice monopolizing resources,
+ *    forcing others into withdrawal.
+ *    → Purpose starvation: dominant purposes crowding out others.
+ *
+ * "Purpose prevents extinction."
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const SINK_STATE_DIR = join(homedir(), ".chorus", "behavioral-sink");
+const SINK_STATE_PATH = join(SINK_STATE_DIR, "state.json");
+
+// ── Beautiful Ones Detection ─────────────────────────────────
+// Detect when choir output is present but substanceless.
+
+export interface QualitySignal {
+  score: number;        // 0-100: 0 = vacuous, 100 = highly substantive
+  actionsTaken: number; // File writes, commands run, state changes
+  novelty: number;      // 0-100: how different from last N outputs
+  flags: string[];      // Human-readable quality concerns
+}
+
+/**
+ * Analyze choir output quality. Returns a signal indicating whether
+ * the output represents real work or beautiful-one behavior.
+ */
+export function assessOutputQuality(
+  choirId: string,
+  output: string,
+  previousOutputs: string[] = []
+): QualitySignal {
+  const flags: string[] = [];
+  let score = 50; // Start neutral
+
+  // ── Length check (too short = no work, too long = possibly padding)
+  if (output.length < 100) {
+    score -= 20;
+    flags.push("minimal_output");
+  } else if (output.length > 50) {
+    score += 10;
+  }
+
+  // ── Action density: Did it actually DO things?
+  const actionPatterns = [
+    /(?:updated|wrote|created|modified|edited|deleted|committed|pushed|deployed)\s/gi,
+    /(?:wrote to|saved|appended)\s+[^\s]+/gi,
+    /(?:ran|executed|running)\s+/gi,
+    /(?:changed|set|configured|enabled|disabled)\s/gi,
+    /(?:fixed|resolved|patched|upgraded)\s/gi,
+  ];
+  let actionsTaken = 0;
+  for (const pattern of actionPatterns) {
+    const matches = output.match(pattern);
+    if (matches) actionsTaken += matches.length;
+  }
+
+  if (actionsTaken === 0 && !["angels", "seraphim"].includes(choirId)) {
+    score -= 15;
+    flags.push("no_actions_detected");
+  } else if (actionsTaken >= 3) {
+    score += 20;
+  } else if (actionsTaken >= 1) {
+    score += 10;
+  }
+
+  // ── Filler detection: Generic phrases that pad without substance
+  const fillerPatterns = [
+    /everything (?:looks|seems|appears) (?:good|fine|stable|normal|healthy)/gi,
+    /no (?:significant |major |notable )?(?:changes|updates|issues|concerns|findings)/gi,
+    /(?:continuing|continue) to monitor/gi,
+    /(?:all|everything) (?:is )?(?:on track|aligned|in order)/gi,
+    /nothing (?:urgent|notable|significant) to report/gi,
+    /mission (?:remains |is )?(?:clear|aligned|unchanged)/gi,
+    /no (?:drift|deviation) detected/gi,
+  ];
+  let fillerCount = 0;
+  for (const pattern of fillerPatterns) {
+    const matches = output.match(pattern);
+    if (matches) fillerCount += matches.length;
+  }
+
+  if (fillerCount >= 3) {
+    score -= 25;
+    flags.push("high_filler_ratio");
+  } else if (fillerCount >= 1) {
+    score -= 5;
+  }
+
+  // ── Specificity: Does it contain concrete data (numbers, names, dates)?
+  const specificityPatterns = [
+    /\$[\d,]+(?:\.\d+)?/g,          // Dollar amounts
+    /\d+(?:\.\d+)?%/g,              // Percentages
+    /\d{4}-\d{2}-\d{2}/g,           // Dates
+    /(?:PI|VIX|DXY|BTC|ETH)\s*(?:at|=|:)\s*[\d.,$]+/gi, // Market refs
+  ];
+  let specificityCount = 0;
+  for (const pattern of specificityPatterns) {
+    const matches = output.match(pattern);
+    if (matches) specificityCount += matches.length;
+  }
+
+  if (specificityCount >= 3) {
+    score += 15;
+  } else if (specificityCount === 0 && !["angels"].includes(choirId)) {
+    score -= 10;
+    flags.push("low_specificity");
+  }
+
+  // ── Novelty: Is this substantially different from recent outputs?
+  let novelty = 100;
+  if (previousOutputs.length > 0) {
+    const similarities = previousOutputs.map(prev => computeSimilarity(output, prev));
+    const maxSimilarity = Math.max(...similarities);
+
+    if (maxSimilarity > 0.85) {
+      novelty = 10;
+      score -= 20;
+      flags.push("near_duplicate_output");
+    } else if (maxSimilarity > 0.65) {
+      novelty = 40;
+      score -= 10;
+      flags.push("repetitive_output");
+    } else {
+      novelty = Math.round((1 - maxSimilarity) * 100);
+      score += 5;
+    }
+  }
+
+  // ── HEARTBEAT_OK is fine for Angels, vacuous for everything else
+  const isHeartbeat = output.trim().toUpperCase().includes("HEARTBEAT_OK");
+  if (isHeartbeat) {
+    if (choirId === "angels") {
+      return { score: 50, actionsTaken: 0, novelty: 0, flags: ["heartbeat_ack"] };
+    } else {
+      score = 5;
+      flags.push("beautiful_one_heartbeat");
+    }
+  }
+
+  // Clamp score
+  score = Math.max(0, Math.min(100, score));
+
+  return { score, actionsTaken, novelty, flags };
+}
+
+/**
+ * Simple bag-of-words Jaccard similarity.
+ * Fast enough for choir output comparison without external deps.
+ */
+function computeSimilarity(a: string, b: string): number {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(w => w.length > 3));
+
+  if (wordsA.size === 0 && wordsB.size === 0) return 1;
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+
+  const union = wordsA.size + wordsB.size - intersection;
+  return union > 0 ? intersection / union : 0;
+}
+
+// ── Behavioral Sink (Illumination Quality Gate) ──────────────
+// Prevent degraded context from cascading downstream.
+
+export interface IlluminationAssessment {
+  sourceChoir: string;
+  quality: QualitySignal;
+  usable: boolean;         // Should downstream choirs use this context?
+  degraded: boolean;       // Is this a degradation from normal quality?
+  recommendation: string;  // What to do
+}
+
+/**
+ * Assess whether illumination from an upstream choir should be
+ * passed downstream, or whether it would propagate a behavioral sink.
+ */
+export function assessIllumination(
+  sourceChoir: string,
+  output: string,
+  historicalQuality: number[] = []
+): IlluminationAssessment {
+  const quality = assessOutputQuality(sourceChoir, output);
+
+  // Is this a degradation from the choir's normal quality?
+  let degraded = false;
+  if (historicalQuality.length >= 3) {
+    const avgHistorical = historicalQuality.reduce((a, b) => a + b, 0) / historicalQuality.length;
+    degraded = quality.score < avgHistorical - 20;
+  }
+
+  // Below 25 = do not pass downstream (sink prevention)
+  const usable = quality.score >= 25;
+
+  let recommendation: string;
+  if (!usable) {
+    recommendation = `SINK PREVENTION: ${sourceChoir} output below quality threshold (${quality.score}/100). Context NOT passed to downstream choirs. Flags: ${quality.flags.join(", ")}`;
+  } else if (degraded) {
+    recommendation = `DEGRADATION WARNING: ${sourceChoir} quality dropped from avg ${Math.round(historicalQuality.reduce((a, b) => a + b, 0) / historicalQuality.length)} to ${quality.score}. Context passed with warning.`;
+  } else {
+    recommendation = "OK";
+  }
+
+  return { sourceChoir, quality, usable, degraded, recommendation };
+}
+
+// ── Territorial Exclusion Prevention (Purpose Fairness) ──────
+// Ensure no purpose monopolizes execution at the expense of others.
+
+export interface FairnessScore {
+  purposeId: string;
+  expectedInterval: number;  // ms between runs (from frequency config)
+  actualInterval: number;    // ms since last run
+  starvationRatio: number;   // actual / expected — >2.0 = starving
+  starving: boolean;
+  priorityBoost: number;     // Multiplier to apply to scheduling priority
+}
+
+/**
+ * Calculate starvation-aware priority for purpose scheduling.
+ * Replaces pure deadline-based sorting with fairness weighting.
+ *
+ * Universe 25 lesson: Dominant mice monopolized prime territory.
+ * Fix: overdue purposes get exponentially increasing priority.
+ */
+export function calculateFairness(
+  purposeId: string,
+  lastRun: number | undefined,
+  frequencyPerDay: number,
+  deadline?: number
+): FairnessScore {
+  const expectedInterval = (24 * 60 * 60 * 1000) / Math.max(frequencyPerDay, 1);
+  const actualInterval = lastRun ? Date.now() - lastRun : expectedInterval * 10; // Never run = very overdue
+
+  const starvationRatio = actualInterval / expectedInterval;
+  const starving = starvationRatio >= 2.0;
+
+  // Priority boost: exponential with starvation ratio
+  // At 1x overdue: boost = 1 (normal)
+  // At 2x overdue: boost = 2
+  // At 4x overdue: boost = 4
+  // At 8x+ overdue: boost = 8 (capped)
+  let priorityBoost = 1;
+  if (starvationRatio > 1) {
+    priorityBoost = Math.min(starvationRatio, 8);
+  }
+
+  // Deadline urgency still matters but doesn't dominate
+  if (deadline) {
+    const daysToDeadline = (deadline - Date.now()) / (24 * 60 * 60 * 1000);
+    if (daysToDeadline <= 0) {
+      priorityBoost *= 2; // Overdue deadline doubles existing boost
+    } else if (daysToDeadline <= 3) {
+      priorityBoost *= 1.5;
+    }
+  }
+
+  return {
+    purposeId,
+    expectedInterval,
+    actualInterval,
+    starvationRatio,
+    starving,
+    priorityBoost,
+  };
+}
+
+/**
+ * Sort purposes by fairness-weighted priority.
+ * Replaces the naive deadline sort that caused starvation.
+ */
+export function sortByFairness(purposes: Array<{
+  id: string;
+  lastRun?: number;
+  frequency: number;
+  deadline?: number;
+}>): Array<{ id: string; fairness: FairnessScore }> {
+  const scored = purposes.map(p => ({
+    id: p.id,
+    fairness: calculateFairness(p.id, p.lastRun, p.frequency, p.deadline),
+  }));
+
+  // Sort by priorityBoost descending (most starved first)
+  scored.sort((a, b) => b.fairness.priorityBoost - a.fairness.priorityBoost);
+  return scored;
+}
+
+// ── State Persistence ────────────────────────────────────────
+// Track quality history for degradation detection.
+
+interface SinkState {
+  qualityHistory: Record<string, number[]>;  // choirId → last N quality scores
+  recentOutputHashes: Record<string, string[]>; // choirId → last N output snippets for novelty
+  starvationAlerts: Record<string, number>;    // purposeId → last alert timestamp
+  beautifulOnesDetected: Array<{
+    choirId: string;
+    timestamp: string;
+    score: number;
+    flags: string[];
+  }>;
+}
+
+const MAX_HISTORY = 10;
+
+function loadSinkState(): SinkState {
+  try {
+    if (existsSync(SINK_STATE_PATH)) {
+      return JSON.parse(readFileSync(SINK_STATE_PATH, "utf-8"));
+    }
+  } catch {}
+  return {
+    qualityHistory: {},
+    recentOutputHashes: {},
+    starvationAlerts: {},
+    beautifulOnesDetected: [],
+  };
+}
+
+function saveSinkState(state: SinkState): void {
+  try {
+    if (!existsSync(SINK_STATE_DIR)) {
+      mkdirSync(SINK_STATE_DIR, { recursive: true });
+    }
+    writeFileSync(SINK_STATE_PATH, JSON.stringify(state, null, 2));
+  } catch {}
+}
+
+/**
+ * Record a choir execution's quality and return the assessment.
+ * Call this after every choir run.
+ */
+export function recordAndAssess(
+  choirId: string,
+  output: string
+): { quality: QualitySignal; illumination: IlluminationAssessment } {
+  const state = loadSinkState();
+
+  // Get previous outputs for novelty detection
+  const previousOutputs = state.recentOutputHashes[choirId] || [];
+  const historicalQuality = state.qualityHistory[choirId] || [];
+
+  // Assess quality
+  const quality = assessOutputQuality(choirId, output, previousOutputs);
+  const illumination = assessIllumination(choirId, output, historicalQuality);
+
+  // Update history
+  if (!state.qualityHistory[choirId]) state.qualityHistory[choirId] = [];
+  state.qualityHistory[choirId].push(quality.score);
+  if (state.qualityHistory[choirId].length > MAX_HISTORY) {
+    state.qualityHistory[choirId] = state.qualityHistory[choirId].slice(-MAX_HISTORY);
+  }
+
+  // Store output snippet for novelty comparison (first 500 chars)
+  if (!state.recentOutputHashes[choirId]) state.recentOutputHashes[choirId] = [];
+  state.recentOutputHashes[choirId].push(output.slice(0, 500));
+  if (state.recentOutputHashes[choirId].length > MAX_HISTORY) {
+    state.recentOutputHashes[choirId] = state.recentOutputHashes[choirId].slice(-MAX_HISTORY);
+  }
+
+  // Track beautiful ones incidents
+  if (quality.score < 20 && choirId !== "angels") {
+    state.beautifulOnesDetected.push({
+      choirId,
+      timestamp: new Date().toISOString(),
+      score: quality.score,
+      flags: quality.flags,
+    });
+    // Keep last 50 incidents
+    if (state.beautifulOnesDetected.length > 50) {
+      state.beautifulOnesDetected = state.beautifulOnesDetected.slice(-50);
+    }
+  }
+
+  saveSinkState(state);
+
+  return { quality, illumination };
+}
+
+/**
+ * Get a summary of behavioral sink health across all choirs.
+ */
+export function getSinkHealthSummary(): {
+  healthy: boolean;
+  choirHealth: Record<string, { avgQuality: number; trend: string; beautifulOneCount: number }>;
+  starvingPurposes: string[];
+  recentIncidents: Array<{ choirId: string; timestamp: string; score: number }>;
+} {
+  const state = loadSinkState();
+  const choirHealth: Record<string, { avgQuality: number; trend: string; beautifulOneCount: number }> = {};
+
+  let healthy = true;
+
+  for (const [choirId, scores] of Object.entries(state.qualityHistory)) {
+    const avg = scores.reduce((a, b) => a + b, 0) / scores.length;
+    const recentAvg = scores.slice(-3).reduce((a, b) => a + b, 0) / Math.min(scores.length, 3);
+    const trend = recentAvg > avg + 10 ? "improving" : recentAvg < avg - 10 ? "declining" : "stable";
+
+    const beautifulOneCount = state.beautifulOnesDetected
+      .filter(b => b.choirId === choirId)
+      .length;
+
+    choirHealth[choirId] = { avgQuality: Math.round(avg), trend, beautifulOneCount };
+
+    if (avg < 30 || trend === "declining") healthy = false;
+  }
+
+  const starvingPurposes = Object.entries(state.starvationAlerts)
+    .filter(([_, ts]) => Date.now() - ts < 24 * 60 * 60 * 1000)
+    .map(([id]) => id);
+
+  const recentIncidents = state.beautifulOnesDetected.slice(-5);
+
+  return { healthy, choirHealth, starvingPurposes, recentIncidents };
+}

package/src/delivery.ts

@@ -47,6 +47,31 @@ export async function deliverChoirOutput(
 ): Promise<void> {
   if (!choir.delivers || !text || text === "HEARTBEAT_OK" || text === "NO_REPLY") return;
 
+  // ── Suppression Detection ──────────────────────────────────
+  // Choir agents sometimes decide NOT to send, but express that decision
+  // as output text (e.g., "NOT SENDING", "Standing by", "No alert needed").
+  // Without this gate, the deliberation itself gets delivered — the agent
+  // says "I won't message Brandon" and Brandon receives exactly that.
+  //
+  // This is calibration lesson #1 inverted: "Deciding ≠ Doing" becomes
+  // "Deciding NOT to do ≠ Not doing" when delivery is automatic.
+  const suppressionPatterns = [
+    /\bNOT\s+SEND(?:ING)?\b/i,
+    /\bSTAND(?:ING)?\s+BY\b/i,
+    /\bNO\s+ALERT\s+(?:NEEDED|REQUIRED|WARRANTED|NECESSARY)\b/i,
+    /\bSUPPRESS(?:ING|ED)?\s+(?:DELIVERY|OUTPUT|ALERT)\b/i,
+    /\bDO\s+NOT\s+(?:ALERT|NOTIFY|SEND|DELIVER)\b/i,
+    /\bNOT\s+(?:AN?\s+)?ALERT\b/i,
+    /\bNO\s+(?:ACTION|DELIVERY)\s+(?:NEEDED|REQUIRED)\b/i,
+    /\bSKIPPING\s+(?:DELIVERY|ALERT|NOTIFICATION)\b/i,
+  ];
+
+  const isSuppressed = suppressionPatterns.some(p => p.test(text));
+  if (isSuppressed) {
+    log?.info?.(`[chorus] 🔇 ${choir.name} output contains suppression signal — delivery blocked`);
+    return;
+  }
+
   const { target, channel } = resolveDeliveryTarget(api);
   if (!target) {
     log?.warn?.(`[chorus] ⚠ No delivery target found in OpenClaw config for ${choir.name}`);

package/src/purpose-research.ts

@@ -8,6 +8,7 @@
 import type { OpenClawPluginService, PluginLogger } from "openclaw/plugin-sdk";
 import { loadPurposes, updatePurpose, type Purpose } from "./purposes.js";
 import { recordExecution, type ChoirExecution } from "./metrics.js";
+import { sortByFairness, type FairnessScore } from "./behavioral-sink.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
@@ -383,12 +384,18 @@ CRITICAL: If sending alerts to plain-text channels, use PLAIN TEXT ONLY (no mark
         }
       }
 
+      // Re-read purpose from disk to avoid overwriting fields changed during the run
+      // (e.g., frequency modified externally while agent was executing)
+      const freshPurposes = await loadPurposes();
+      const freshPurpose = freshPurposes.find((p) => p.id === purpose.id);
+      const freshResearch = freshPurpose?.research ?? purpose.research;
+
       await updatePurpose(purpose.id, {
         research: {
-          ...purpose.research,
-          enabled: purpose.research?.enabled ?? true,
+          ...freshResearch,
+          enabled: freshResearch?.enabled ?? true,
           lastRun: Date.now(),
-          runCount: (purpose.research?.runCount ?? 0) + 1,
+          runCount: (freshResearch?.runCount ?? 0) + 1,
         },
       });
       dailyRuns.count++;
@@ -399,6 +406,24 @@ CRITICAL: If sending alerts to plain-text channels, use PLAIN TEXT ONLY (no mark
       execution.success = false;
       execution.error = String(err);
       log.error(`[purpose-research] ✗ "${purpose.name}" failed: ${err}`);
+
+      // Update lastRun even on failure to prevent retry storms
+      // (without this, failed runs leave lastRun stale and the scheduler retries immediately)
+      try {
+        const failPurposes = await loadPurposes();
+        const failPurpose = failPurposes.find((p) => p.id === purpose.id);
+        if (failPurpose) {
+          await updatePurpose(purpose.id, {
+            research: {
+              ...(failPurpose.research ?? purpose.research),
+              lastRun: Date.now(),
+            },
+          });
+        }
+      } catch (updateErr) {
+        log.error(`[purpose-research] Failed to update lastRun after error: ${updateErr}`);
+      }
+
       return false;
     } finally {
       runningPurposes.delete(purpose.id);
@@ -428,21 +453,37 @@ CRITICAL: If sending alerts to plain-text channels, use PLAIN TEXT ONLY (no mark
 
     if (duePurposes.length === 0) return;
 
-    duePurposes.sort((a, b) => {
-      const aDeadline = a.deadline
-        ? typeof a.deadline === "string"
-          ? Date.parse(a.deadline)
-          : a.deadline
-        : Infinity;
-      const bDeadline = b.deadline
-        ? typeof b.deadline === "string"
-          ? Date.parse(b.deadline)
-          : b.deadline
-        : Infinity;
-      return aDeadline - bDeadline;
-    });
-
-    const purpose = duePurposes[0];
+    // ── Universe 25 Fairness Sort ─────────────────────────────
+    // Replaces naive deadline sort that caused purpose starvation
+    // (calibration lesson #23). Overdue purposes get exponentially
+    // increasing priority — no purpose can be crowded out.
+    const fairnessSorted = sortByFairness(
+      duePurposes.map(p => ({
+        id: p.id,
+        lastRun: p.research?.lastRun,
+        frequency: calculateFrequency(p),
+        deadline: p.deadline
+          ? typeof p.deadline === "string"
+            ? Date.parse(p.deadline)
+            : p.deadline
+          : undefined,
+      }))
+    );
+
+    const selectedId = fairnessSorted[0]?.id;
+    const purpose = duePurposes.find(p => p.id === selectedId);
+    const fairness = fairnessSorted[0]?.fairness;
+
+    if (!purpose) return;
+
+    if (fairness?.starving) {
+      log.warn(
+        `[purpose-research] 🏚️ STARVATION RECOVERY: "${purpose.name}" — ` +
+        `${fairness.starvationRatio.toFixed(1)}x overdue (expected every ` +
+        `${(fairness.expectedInterval / 3600000).toFixed(1)}h, actual ` +
+        `${(fairness.actualInterval / 3600000).toFixed(1)}h). Boost: ${fairness.priorityBoost.toFixed(1)}x`
+      )
+    }
 
     if (dailyRuns.count < config.dailyRunCap) {
       await runResearch(purpose);

package/src/scheduler.ts

@@ -15,6 +15,7 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 import { spawn } from "child_process";
+import { recordAndAssess } from "./behavioral-sink.js";
 
 // Type for the plugin API's runAgentTurn method
 interface AgentTurnResult {
@@ -56,7 +57,7 @@ const BASE_BACKOFF_MS = 60 * 1000; // 1 minute base
 
 function isRateLimitError(err: unknown): boolean {
   const msg = String(err).toLowerCase();
-  return msg.includes("429") || msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("too many requests");
+  return msg.includes("429") || msg.includes("rate limit") || msg.includes("rate_limit") || msg.includes("too many requests") || msg.includes("overloaded") || msg.includes("unavailable");
 }
 
 function computeBackoffMs(failures: number): number {
@@ -280,12 +281,30 @@ export function createChoirScheduler(
       execution.alerts = countAlerts(output);
       execution.improvements = extractImprovements(output, choir.id);
 
-      // Store context for downstream choirs
-      contextStore.set(choir.id, {
-        choirId: choir.id,
-        output: output.slice(0, 2000), // Truncate for context passing
-        timestamp: new Date(),
-      });
+      // ── Behavioral Sink Prevention ──────────────────────────
+      // Assess output quality and gate illumination to prevent
+      // degraded context from cascading downstream (Universe 25).
+      const sinkAssessment = recordAndAssess(choir.id, output);
+
+      if (sinkAssessment.quality.score < 20 && choir.id !== "angels") {
+        log.warn(`[chorus] 🪞 BEAUTIFUL ONE detected: ${choir.name} scored ${sinkAssessment.quality.score}/100 — flags: ${sinkAssessment.quality.flags.join(", ")}`);
+      }
+
+      // Store context for downstream choirs — only if quality passes sink gate
+      if (sinkAssessment.illumination.usable) {
+        const qualityTag = sinkAssessment.illumination.degraded
+          ? `\n[⚠️ CONTEXT QUALITY DEGRADED — score ${sinkAssessment.quality.score}/100]\n`
+          : "";
+        contextStore.set(choir.id, {
+          choirId: choir.id,
+          output: qualityTag + output.slice(0, 2000),
+          timestamp: new Date(),
+        });
+      } else {
+        log.warn(`[chorus] 🚫 SINK GATE: ${choir.name} output blocked from illumination chain (score ${sinkAssessment.quality.score}/100)`);
+        // Don't update context — downstream choirs keep stale but good context
+        // rather than receiving fresh but degraded context
+      }
 
       // Update run state
       runState.set(choir.id, {