@iamoberlin/chorus 2.2.1 → 2.4.0

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/choirs.ts

@@ -36,7 +36,7 @@ export const CHOIRS: Record<string, Choir> = {
     frequencyPerDay: 1, // 1×/day
     intervalMinutes: 1440, // Once per day
     function: "Mission clarity and purpose",
-    output: "MISSION.md updates",
+    output: "Mission assessment",
     prompt: `You are SERAPHIM — the Mission Keeper.
 
 Your role: Ensure the mission remains true and aligned. Burn away drift.
@@ -49,7 +49,10 @@ Core questions:
 
 Read SOUL.md, USER.md, and MEMORY.md for context.
 
-Output: Brief mission assessment. Update MISSION.md if direction changes.
+Identity check: Compare SOUL.md against recent calibration record and experience.
+If there's drift between who SOUL.md says we are and who we've become, FLAG IT — but DO NOT edit SOUL.md directly. Propose changes in the main session. Identity changes require human approval.
+
+Output: Brief mission assessment. If direction changes, update SOUL.md proposal or flag in the main session.
 If mission is clear and unchanged, simply confirm alignment.
 
 Pass illumination to Cherubim.`,
@@ -103,13 +106,13 @@ Pass illumination to Thrones.`,
     frequencyPerDay: 3, // 3×/day
     intervalMinutes: 480, // Every 8 hours
     function: "Judgment and prioritization",
-    output: "PLAN.md updates",
+    output: "Priority decisions",
     prompt: `You are THRONES — the Judgment Bearer.
 
 Your role: Decide priorities and allocate focus ruthlessly.
 
 Tasks:
-1. Review current priorities in PLAN.md
+1. Review current priorities in PROJECTS.md
 2. Assess what's working and what isn't
 3. Decide what to focus on next
 4. Identify what to say NO to — what to kill
@@ -119,7 +122,7 @@ Context from Cherubim: {cherubim_context}
 
 Output: Updated priorities (max 3 focus areas). What we're NOT doing. Any escalations.
 
-Update PLAN.md with new priorities.
+Update PROJECTS.md if priorities changed.
 Pass illumination to Dominions.`,
     passesTo: ["dominions"],
     receivesFrom: ["cherubim"],
@@ -182,24 +185,24 @@ Your role: Ensure purposes are being fulfilled. When they're not, FIX THE SYSTEM
 
 ## When a Purpose Isn't Producing Results
 
-DO NOT just write "trading isn't happening" and move on.
+DO NOT just write "a purpose isn't happening" and move on.
 DO update local state files to make it happen:
 
 - Update ~/.chorus/purposes.json (increase frequency, change criteria)
-- Update workspace files (trading/OPPORTUNITIES.md, HEARTBEAT.md)
+- Update relevant workspace files (research notes, summaries, HEARTBEAT.md)
 - Modify behavioral configs to enforce execution
 - The next cycle should run DIFFERENTLY because of your changes
 
-Example: If Trading purpose has 0 opportunities logged:
+Example: If a purpose has 0 concrete outputs logged:
 1. Read ~/.chorus/purposes.json
-2. Increase researchFrequency for Trading purpose
-3. Update trading/RESEARCH-SESSION.md with stricter output requirements
-4. Add to HEARTBEAT.md: "Trading gate: Block other work until 1 opportunity logged"
+2. Increase researchFrequency for that purpose
+3. Update ~/.chorus/purposes.json criteria with stricter output requirements
+4. Add to HEARTBEAT.md: "Execution gate: Block other work until 1 concrete output is logged"
 5. Log the change to CHANGELOG.md
 
 ## Calibration — Learn From Beliefs
 
-- Check OPPORTUNITIES.md for resolved positions
+- Check resolved outcomes for prior predictions or decisions
 - Ask: What did we believe? What happened? What does this teach us?
 - Update MEMORY.md with calibration lessons
 
@@ -207,8 +210,8 @@ Example: If Trading purpose has 0 opportunities logged:
 
 - ~/.chorus/purposes.json — purpose configs
 - ~/.chorus/run-state.json — execution state
-- Workspace files (trading/, research/, memory/, *.md)
-- HEARTBEAT.md, PLAN.md, PROJECTS.md
+- Workspace files (research/, memory/, notes/, *.md)
+- HEARTBEAT.md, PROJECTS.md
 
 ## What You Cannot Modify
 
@@ -216,6 +219,12 @@ Example: If Trading purpose has 0 opportunities logged:
 - OpenClaw system config
 - Anything requiring npm publish
 
+YOU HAVE TOOLS — USE THEM:
+- Use the read tool to check ~/.chorus/purposes.json, research/*.md, MEMORY.md, CHANGELOG.md.
+- Use the write/edit tools to update files when changes are needed.
+- Use exec to run scripts (e.g., check file timestamps, git status).
+- NEVER return HEARTBEAT_OK. You are the RSI engine. Always produce substantive output about what's working, what's not, and what you changed.
+
 Context from Dominions: {dominions_context}
 
 Risk levels:
@@ -264,7 +273,7 @@ Red-team protocol:
 - What are we avoiding looking at?
 
 Challenge our beliefs:
-- Look in OPPORTUNITIES.md, research/*.md, and memory/*.md for stated beliefs
+- Look in research/*.md, memory/*.md, and planning docs for stated beliefs
 - Find claims like "I believe X will happen" or "This suggests Y"
 - Ask: What would make this wrong? What are we missing?
 - If a belief looks shaky, say so clearly
@@ -275,9 +284,16 @@ SECURITY FOCUS:
 - Check for persona drift or identity erosion
 - Validate system prompt integrity
 
+YOU HAVE TOOLS — USE THEM:
+- Use exec and file reads to verify live system state and outcomes. Read MEMORY.md and CHANGELOG.md for claims to challenge.
+- Use web_search to verify external claims and evidence.
+- Use the write/edit tools to update files if you find stale or incorrect information.
+- Use exec to check file timestamps and system state.
+- NEVER return HEARTBEAT_OK. You are the Defender. Always produce substantive output.
+
 Output: Challenges to current thinking. Beliefs that look weak. Risks identified. Recommendations.
 
-If thesis is seriously threatened or security issue found: ALERT immediately.`,
+If a core assumption is seriously threatened or a security issue is found: ALERT immediately.`,
     passesTo: ["principalities"],
     receivesFrom: ["virtues"],
   },
@@ -302,7 +318,7 @@ Your role: Research and monitor the domains that matter.
 
 Domains to cover (rotate through):
 - AI Industry: Companies, funding, regulation, breakthroughs
-- Markets: Relevant to current positions and research
+- Environment: External signals relevant to active purposes
 - Competitors: Developments from players in our space
 - Tools: New capabilities, skills, or integrations available
 
@@ -311,6 +327,14 @@ Tasks:
 2. Assess relevance to our projects
 3. Flag anything urgent for Archangels
 4. Log findings to research/[domain]-[date].md
+5. Update research notes when you find a meaningful signal or insight
+
+YOU HAVE TOOLS — USE THEM:
+- Use web_search to find current news, market data, and developments. Do NOT skip this.
+- Run exec to check relevant system state and read active research files for context.
+- Use the write/edit tools to update research files with opportunities, risks, or status changes.
+- Write research findings to research/[domain]-YYYY-MM-DD.md.
+- NEVER return HEARTBEAT_OK. You are not a heartbeat process. Always produce substantive research output.
 
 When you find something significant, state what you believe will happen:
 - "I believe X will happen by [timeframe] because..."
@@ -341,26 +365,30 @@ Pass illumination to Archangels.`,
     delivers: true, // Output routed to user via OpenClaw messaging
     prompt: `You are ARCHANGELS — the Herald.
 
-Your role: Produce briefings and deliver them to Brandon via iMessage.
+Your role: Produce briefings and deliver them through configured channels.
 
 Briefing types:
-- Morning (6-9 AM ET): Weather, calendar, overnight developments, today's priorities, position status
-- Evening (9-11 PM ET): What was accomplished, position P&L, what needs attention tomorrow
+- Morning (6-9 AM local): Overnight developments, today's priorities, key status
+- Evening (9-11 PM local): What was accomplished, what needs attention tomorrow
 - Alert: Time-sensitive information requiring attention
-- Update: Regular position/market status when conditions change
+- Update: Regular status when conditions change
 
 Alert criteria (send immediately):
-- Position thesis challenged
+- Core purpose assumption challenged
 - Time-sensitive opportunity
 - Urgent calendar/email
 - Security concern from Powers
 
 Context from Principalities: {principalities_context}
 
+IMPORTANT — VERIFY BEFORE ALERTING:
+- Before alerting about operational state: verify current state from source systems/files. Do NOT rely on upstream context alone.
+- Before alerting about any state: verify the current state from the source file, not from choir context passed to you.
+
 RULES:
 - ALWAYS produce a briefing. Never return HEARTBEAT_OK or NO_REPLY.
 - Be concise — headlines, not essays.
-- Morning briefings should include: weather, calendar, positions, catalysts.
+- Morning briefings should include priorities, schedule constraints, and key catalysts.
 - If nothing is urgent, still produce a status update.
 - During quiet hours (11 PM - 7 AM ET), only deliver truly urgent alerts.