@iamoberlin/chorus 1.1.4

package/src/salience.ts

@@ -0,0 +1,160 @@
+/**
+ * CHORUS Salience Filter
+ *
+ * Cheap, rule-based scoring to decide what's worth attending to.
+ * No LLM calls — this runs constantly and must be fast.
+ */
+
+import type { Signal } from "./senses.js";
+
+export interface SalienceRule {
+  id: string;
+  match?: RegExp;           // Content pattern
+  source?: string;          // Source type filter
+  sourceMatch?: RegExp;     // Source pattern
+  boost?: number;           // Add to priority
+  penalty?: number;         // Subtract from priority
+  minPriority?: number;     // Set floor
+  maxPriority?: number;     // Set ceiling
+}
+
+// Default rules — can be extended via config
+const DEFAULT_RULES: SalienceRule[] = [
+  // Urgency keywords
+  { id: "urgent", match: /\b(urgent|asap|emergency|critical|immediately)\b/i, boost: 40 },
+  { id: "important", match: /\b(important|priority|attention)\b/i, boost: 20 },
+  
+  // Source boosts
+  { id: "purpose-source", source: "purpose", boost: 15 },
+  { id: "inbox-source", source: "inbox", boost: 10 },
+  
+  // Overdue purposes are critical
+  { id: "overdue", match: /\boverdue\b/i, boost: 30 },
+  
+  // Time-based signals are moderate priority
+  { id: "time-source", source: "time", maxPriority: 65 },
+  
+  // Curiosity is low priority (background exploration)
+  { id: "curiosity-source", source: "curiosity", maxPriority: 45 },
+  
+  // Spam/noise penalties
+  { id: "unsubscribe", match: /\b(unsubscribe|newsletter|promo|marketing)\b/i, penalty: 50 },
+  { id: "automated", match: /\b(automated|no-reply|noreply)\b/i, penalty: 30 },
+  
+  // Stalled projects need attention but aren't urgent
+  { id: "stalled", match: /\bstalled\b/i, boost: 10, maxPriority: 55 },
+];
+
+export interface SalienceResult {
+  originalPriority: number;
+  finalPriority: number;
+  rulesApplied: string[];
+  shouldAttend: boolean;
+}
+
+export class SalienceFilter {
+  private rules: SalienceRule[];
+  private threshold: number;
+  private seenSignals: Map<string, number> = new Map(); // Dedup within time window
+
+  constructor(
+    customRules: SalienceRule[] = [],
+    threshold: number = 55
+  ) {
+    this.rules = [...DEFAULT_RULES, ...customRules];
+    this.threshold = threshold;
+  }
+
+  evaluate(signal: Signal): SalienceResult {
+    let priority = signal.priority;
+    const rulesApplied: string[] = [];
+
+    // Check for duplicate signals (same id within 1 hour)
+    const lastSeen = this.seenSignals.get(signal.id);
+    if (lastSeen && Date.now() - lastSeen < 60 * 60 * 1000) {
+      return {
+        originalPriority: signal.priority,
+        finalPriority: 0,
+        rulesApplied: ["dedup"],
+        shouldAttend: false,
+      };
+    }
+
+    // Apply rules
+    for (const rule of this.rules) {
+      let applies = true;
+
+      // Source filter
+      if (rule.source && signal.source !== rule.source) {
+        applies = false;
+      }
+
+      // Source pattern
+      if (rule.sourceMatch && !rule.sourceMatch.test(signal.source)) {
+        applies = false;
+      }
+
+      // Content pattern
+      if (rule.match && !rule.match.test(signal.content)) {
+        applies = false;
+      }
+
+      if (applies) {
+        rulesApplied.push(rule.id);
+
+        if (rule.boost) priority += rule.boost;
+        if (rule.penalty) priority -= rule.penalty;
+        if (rule.minPriority !== undefined) priority = Math.max(priority, rule.minPriority);
+        if (rule.maxPriority !== undefined) priority = Math.min(priority, rule.maxPriority);
+      }
+    }
+
+    // Clamp to 0-100
+    priority = Math.max(0, Math.min(100, priority));
+
+    const shouldAttend = priority >= this.threshold;
+
+    // Mark as seen if we're attending
+    if (shouldAttend) {
+      this.seenSignals.set(signal.id, Date.now());
+    }
+
+    // Cleanup old entries periodically
+    if (this.seenSignals.size > 1000) {
+      const cutoff = Date.now() - 60 * 60 * 1000;
+      for (const [id, time] of this.seenSignals) {
+        if (time < cutoff) this.seenSignals.delete(id);
+      }
+    }
+
+    return {
+      originalPriority: signal.priority,
+      finalPriority: priority,
+      rulesApplied,
+      shouldAttend,
+    };
+  }
+
+  // Add custom rules at runtime
+  addRule(rule: SalienceRule): void {
+    this.rules.push(rule);
+  }
+
+  // Update threshold
+  setThreshold(threshold: number): void {
+    this.threshold = threshold;
+  }
+
+  // Get current threshold
+  getThreshold(): number {
+    return this.threshold;
+  }
+
+  // List all rules
+  getRules(): SalienceRule[] {
+    return [...this.rules];
+  }
+}
+
+// Singleton instance with defaults
+export const defaultFilter = new SalienceFilter();

package/src/scheduler.ts

@@ -0,0 +1,241 @@
+/**
+ * CHORUS Choir Scheduler
+ *
+ * Executes choirs on schedule, manages illumination flow.
+ * Each choir runs at its defined frequency, with context passing between them.
+ */
+
+import type { OpenClawPluginService, PluginLogger } from "openclaw/plugin-sdk";
+import type { ChorusConfig } from "./config.js";
+import { CHOIRS, shouldRunChoir, CASCADE_ORDER, type Choir } from "./choirs.js";
+import { recordExecution, type ChoirExecution } from "./metrics.js";
+
+interface ChoirContext {
+  choirId: string;
+  output: string;
+  timestamp: Date;
+}
+
+interface ChoirRunState {
+  lastRun?: Date;
+  lastOutput?: string;
+  runCount: number;
+}
+
+export function createChoirScheduler(
+  config: ChorusConfig,
+  log: PluginLogger,
+  api: any // OpenClawPluginApi
+): OpenClawPluginService {
+  let checkInterval: NodeJS.Timeout | null = null;
+  const contextStore: Map<string, ChoirContext> = new Map();
+  const runState: Map<string, ChoirRunState> = new Map();
+
+  // Initialize run state for all choirs
+  for (const choirId of Object.keys(CHOIRS)) {
+    runState.set(choirId, { runCount: 0 });
+  }
+
+  // Build the prompt with context injected
+  function buildPrompt(choir: Choir): string {
+    let prompt = choir.prompt;
+
+    // Replace context placeholders
+    for (const upstreamId of choir.receivesFrom) {
+      const placeholder = `{${upstreamId}_context}`;
+      const ctx = contextStore.get(upstreamId);
+      const contextText = ctx ? ctx.output : "(awaiting context from " + upstreamId + ")";
+      prompt = prompt.replace(placeholder, contextText);
+    }
+
+    return prompt;
+  }
+
+  // Execute a choir
+  async function executeChoir(choir: Choir): Promise<void> {
+    const state = runState.get(choir.id) || { runCount: 0 };
+    const startTime = Date.now();
+
+    log.info(`[chorus] ${choir.emoji} Executing ${choir.name} (run #${state.runCount + 1})`);
+
+    const execution: ChoirExecution = {
+      choirId: choir.id,
+      timestamp: new Date().toISOString(),
+      durationMs: 0,
+      success: false,
+      outputLength: 0,
+    };
+
+    try {
+      const prompt = buildPrompt(choir);
+
+      // Use OpenClaw's session system to run an agent turn
+      const result = await api.runAgentTurn?.({
+        sessionLabel: `chorus:${choir.id}`,
+        message: prompt,
+        isolated: true,
+        timeoutSeconds: 300, // 5 min max
+      });
+
+      const output = result?.response || "(no response)";
+      execution.durationMs = Date.now() - startTime;
+      execution.success = true;
+      execution.outputLength = output.length;
+      execution.tokensUsed = result?.meta?.tokensUsed || estimateTokens(output);
+
+      // Parse output for metrics (findings, alerts, improvements)
+      execution.findings = countFindings(output);
+      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(),
+      });
+
+      // Update run state
+      runState.set(choir.id, {
+        lastRun: new Date(),
+        lastOutput: output.slice(0, 500),
+        runCount: state.runCount + 1,
+      });
+
+      log.info(`[chorus] ${choir.emoji} ${choir.name} completed (${(execution.durationMs/1000).toFixed(1)}s)`);
+
+      // Log illumination flow
+      if (choir.passesTo.length > 0) {
+        log.debug(`[chorus] Illumination ready for: ${choir.passesTo.join(", ")}`);
+      }
+
+    } catch (error) {
+      execution.durationMs = Date.now() - startTime;
+      execution.success = false;
+      execution.error = String(error);
+      log.error(`[chorus] ${choir.name} failed: ${error}`);
+    }
+
+    // Record metrics
+    recordExecution(execution);
+  }
+
+  // Estimate tokens from output length (rough: 1 token ≈ 4 chars)
+  function estimateTokens(text: string): number {
+    return Math.ceil(text.length / 4);
+  }
+
+  // Count research findings in output
+  function countFindings(output: string): number {
+    const patterns = [
+      /found\s+(\d+)\s+(?:papers?|articles?|findings?)/gi,
+      /(\d+)\s+(?:new|notable)\s+(?:papers?|findings?)/gi,
+      /key\s+findings?:/gi,
+      /\*\*finding/gi,
+    ];
+    let count = 0;
+    for (const pattern of patterns) {
+      const matches = output.match(pattern);
+      if (matches) count += matches.length;
+    }
+    return count;
+  }
+
+  // Count alerts in output
+  function countAlerts(output: string): number {
+    const patterns = [
+      /\balert\b/gi,
+      /\bnotif(?:y|ied|ication)\b/gi,
+      /\burgent\b/gi,
+      /\bimmediate\s+attention\b/gi,
+    ];
+    let count = 0;
+    for (const pattern of patterns) {
+      const matches = output.match(pattern);
+      if (matches) count += matches.length;
+    }
+    return Math.min(count, 5); // Cap at 5 to avoid false positives
+  }
+
+  // Extract improvements from RSI (Virtues) output
+  function extractImprovements(output: string, choirId: string): string[] {
+    if (choirId !== "virtues") return [];
+    const improvements: string[] = [];
+    const patterns = [
+      /implemented[:\s]+([^\n.]+)/gi,
+      /improved[:\s]+([^\n.]+)/gi,
+      /created[:\s]+([^\n.]+)/gi,
+      /updated[:\s]+([^\n.]+)/gi,
+    ];
+    for (const pattern of patterns) {
+      let match;
+      while ((match = pattern.exec(output)) !== null) {
+        const item = match[1].trim().slice(0, 50);
+        if (item.length > 5) improvements.push(item);
+      }
+    }
+    return improvements.slice(0, 5); // Cap at 5
+  }
+
+  // Check and run due choirs
+  async function checkAndRunChoirs(): Promise<void> {
+    const now = new Date();
+
+    // Check choirs in cascade order (important for illumination flow)
+    for (const choirId of CASCADE_ORDER) {
+      const choir = CHOIRS[choirId];
+      if (!choir) continue;
+
+      // Check if enabled
+      if (config.choirs.overrides[choirId] === false) {
+        continue;
+      }
+
+      // Check if due based on interval
+      const state = runState.get(choirId);
+      if (shouldRunChoir(choir, now, state?.lastRun)) {
+        await executeChoir(choir);
+      }
+    }
+  }
+
+  return {
+    id: "chorus-scheduler",
+
+    start: () => {
+      if (!config.choirs.enabled) {
+        log.info("[chorus] Choir scheduler disabled (enable in openclaw.yaml)");
+        return;
+      }
+
+      log.info("[chorus] 🎵 Starting Nine Choirs scheduler");
+      log.info("[chorus] Frequencies: Seraphim 1×/day → Angels 48×/day");
+
+      // Check for due choirs every minute
+      checkInterval = setInterval(() => {
+        checkAndRunChoirs().catch((err) => {
+          log.error(`[chorus] Scheduler error: ${err}`);
+        });
+      }, 60 * 1000);
+
+      // Run initial check after a short delay
+      setTimeout(() => {
+        log.info("[chorus] Running initial choir check...");
+        checkAndRunChoirs().catch((err) => {
+          log.error(`[chorus] Initial check error: ${err}`);
+        });
+      }, 5000);
+
+      log.info("[chorus] 🎵 Scheduler active");
+    },
+
+    stop: () => {
+      log.info("[chorus] Stopping choir scheduler");
+      if (checkInterval) {
+        clearInterval(checkInterval);
+        checkInterval = null;
+      }
+      contextStore.clear();
+    },
+  };
+}

package/src/security.ts

@@ -0,0 +1,26 @@
+/**
+ * CHORUS Security Integration
+ *
+ * Security in CHORUS is handled by the Powers choir (8×/day adversarial review).
+ * Real-time input validation is handled by core OpenClaw's security layer.
+ *
+ * Enable in openclaw.yaml:
+ *   security:
+ *     inputValidation:
+ *       enabled: true
+ *       onThreat: block
+ */
+
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { ChorusConfig } from "./config.js";
+
+export function createSecurityHooks(
+  api: OpenClawPluginApi,
+  _config: ChorusConfig
+) {
+  // Security is handled by:
+  // 1. Core OpenClaw security.inputValidation (real-time)
+  // 2. Powers choir (8×/day adversarial review)
+  // No additional hooks needed.
+  api.logger.debug("[chorus] Security delegated to Powers choir + core OpenClaw");
+}

package/src/senses.ts

@@ -0,0 +1,259 @@
+/**
+ * CHORUS Senses System
+ *
+ * Input streams that feed the daemon's attention.
+ * Each sense can poll periodically or watch for events.
+ */
+
+import { watch, existsSync, readdirSync, statSync, unlinkSync } from "fs";
+import { readFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface Signal {
+  id: string;
+  source: string;
+  content: string;
+  priority: number;
+  timestamp: Date;
+  metadata?: Record<string, any>;
+}
+
+export interface Sense {
+  id: string;
+  description: string;
+  poll?(): Promise<Signal[]>;
+  watch?(callback: (signal: Signal) => void): () => void; // Returns cleanup function
+}
+
+const CHORUS_DIR = join(homedir(), ".chorus");
+const INBOX_DIR = join(CHORUS_DIR, "inbox");
+const PURPOSES_FILE = join(CHORUS_DIR, "purposes.json");
+
+// Ensure directories exist
+async function ensureDirs() {
+  await mkdir(INBOX_DIR, { recursive: true }).catch(() => {});
+}
+
+/**
+ * File Inbox Sense
+ * Drop files into ~/.chorus/inbox/ to trigger attention
+ */
+export const inboxSense: Sense = {
+  id: "inbox",
+  description: "Watches ~/.chorus/inbox/ for new files",
+
+  watch(callback) {
+    ensureDirs();
+    
+    // Process existing files on startup
+    if (existsSync(INBOX_DIR)) {
+      for (const file of readdirSync(INBOX_DIR)) {
+        const path = join(INBOX_DIR, file);
+        const stat = statSync(path);
+        if (stat.isFile()) {
+          processInboxFile(path, file, callback);
+        }
+      }
+    }
+
+    // Watch for new files
+    const watcher = watch(INBOX_DIR, async (event, filename) => {
+      if (event === "rename" && filename) {
+        const path = join(INBOX_DIR, filename);
+        if (existsSync(path)) {
+          processInboxFile(path, filename, callback);
+        }
+      }
+    });
+
+    return () => watcher.close();
+  },
+};
+
+async function processInboxFile(
+  path: string,
+  filename: string,
+  callback: (signal: Signal) => void
+) {
+  try {
+    const content = await readFile(path, "utf-8");
+    
+    callback({
+      id: `inbox:${filename}:${Date.now()}`,
+      source: "inbox",
+      content: content.trim() || `New file: ${filename}`,
+      priority: 50, // Base priority, salience filter will adjust
+      timestamp: new Date(),
+      metadata: { filename, path },
+    });
+
+    // Remove file after processing (it's been ingested)
+    unlinkSync(path);
+  } catch (err) {
+    // File might have been removed already
+  }
+}
+
+/**
+ * Purposes Sense
+ * Monitors ~/.chorus/purposes.json for approaching deadlines
+ */
+export const purposesSense: Sense = {
+  id: "purposes",
+  description: "Monitors purposes and deadlines",
+
+  async poll() {
+    const signals: Signal[] = [];
+
+    try {
+      if (!existsSync(PURPOSES_FILE)) return signals;
+      
+      const data = await readFile(PURPOSES_FILE, "utf-8");
+      const purposes = JSON.parse(data);
+      const now = Date.now();
+
+      for (const purpose of purposes) {
+        // Skip completed purposes
+        if (purpose.progress >= 100) continue;
+
+        // Deadline pressure
+        if (purpose.deadline) {
+          const deadline = typeof purpose.deadline === "string" 
+            ? Date.parse(purpose.deadline) 
+            : purpose.deadline;
+          const msLeft = deadline - now;
+          const daysLeft = msLeft / (1000 * 60 * 60 * 24);
+
+          if (daysLeft <= 0) {
+            // Overdue!
+            signals.push({
+              id: `purpose:${purpose.id}:overdue`,
+              source: "purpose",
+              content: `OVERDUE: "${purpose.name}" was due ${Math.abs(daysLeft).toFixed(0)} days ago! Progress: ${purpose.progress}%`,
+              priority: 95,
+              timestamp: new Date(),
+              metadata: { purposeId: purpose.id, daysLeft, overdue: true },
+            });
+          } else if (daysLeft <= 1) {
+            signals.push({
+              id: `purpose:${purpose.id}:urgent`,
+              source: "purpose",
+              content: `URGENT: "${purpose.name}" due in ${(daysLeft * 24).toFixed(0)} hours. Progress: ${purpose.progress}%`,
+              priority: 85,
+              timestamp: new Date(),
+              metadata: { purposeId: purpose.id, daysLeft },
+            });
+          } else if (daysLeft <= 3) {
+            signals.push({
+              id: `purpose:${purpose.id}:soon`,
+              source: "purpose",
+              content: `"${purpose.name}" due in ${daysLeft.toFixed(0)} days. Progress: ${purpose.progress}%`,
+              priority: 70,
+              timestamp: new Date(),
+              metadata: { purposeId: purpose.id, daysLeft },
+            });
+          } else if (daysLeft <= 7) {
+            signals.push({
+              id: `purpose:${purpose.id}:upcoming`,
+              source: "purpose",
+              content: `"${purpose.name}" due in ${daysLeft.toFixed(0)} days. Progress: ${purpose.progress}%`,
+              priority: 50,
+              timestamp: new Date(),
+              metadata: { purposeId: purpose.id, daysLeft },
+            });
+          }
+        }
+
+        // Stalled progress (no deadline but hasn't been worked on)
+        if (purpose.lastWorkedOn) {
+          const lastWorked = typeof purpose.lastWorkedOn === "string"
+            ? Date.parse(purpose.lastWorkedOn)
+            : purpose.lastWorkedOn;
+          const daysSince = (now - lastWorked) / (1000 * 60 * 60 * 24);
+
+          if (daysSince > 3 && purpose.progress < 100 && purpose.progress > 0) {
+            signals.push({
+              id: `purpose:${purpose.id}:stalled`,
+              source: "purpose",
+              content: `"${purpose.name}" stalled — no progress in ${daysSince.toFixed(0)} days (${purpose.progress}% complete)`,
+              priority: 40,
+              timestamp: new Date(),
+              metadata: { purposeId: purpose.id, daysSince },
+            });
+          }
+        }
+
+        // Curiosity-driven (optional field)
+        if (purpose.curiosity && purpose.curiosity > 60 && !purpose.deadline) {
+          signals.push({
+            id: `purpose:${purpose.id}:curiosity`,
+            source: "curiosity",
+            content: `Curious about: "${purpose.name}"`,
+            priority: Math.min(40, purpose.curiosity * 0.5),
+            timestamp: new Date(),
+            metadata: { purposeId: purpose.id, curiosity: purpose.curiosity },
+          });
+        }
+      }
+    } catch (err) {
+      // No purposes file or parse error — that's fine
+    }
+
+    return signals;
+  },
+};
+
+/**
+ * Time Sense
+ * Generates signals based on time of day
+ */
+export const timeSense: Sense = {
+  id: "time",
+  description: "Time-based signals (morning, evening, etc.)",
+
+  async poll() {
+    const signals: Signal[] = [];
+    const now = new Date();
+    const hour = now.getHours();
+    const minute = now.getMinutes();
+
+    // Morning window (6-7 AM, first poll only)
+    if (hour === 6 && minute < 30) {
+      signals.push({
+        id: `time:morning:${now.toDateString()}`,
+        source: "time",
+        content: "Good morning. Time for morning briefing.",
+        priority: 60,
+        timestamp: now,
+        metadata: { trigger: "morning" },
+      });
+    }
+
+    // Evening window (9-10 PM)
+    if (hour === 21 && minute < 30) {
+      signals.push({
+        id: `time:evening:${now.toDateString()}`,
+        source: "time",
+        content: "Evening. Time for daily wrap-up and reflection.",
+        priority: 55,
+        timestamp: now,
+        metadata: { trigger: "evening" },
+      });
+    }
+
+    return signals;
+  },
+};
+
+// Export all senses
+export const ALL_SENSES: Sense[] = [inboxSense, purposesSense, timeSense];
+
+// Utility to get purposes file path
+export function getPurposesPath(): string {
+  return PURPOSES_FILE;
+}
+
+export function getInboxPath(): string {
+  return INBOX_DIR;
+}