@iamoberlin/chorus 2.2.1 → 2.4.0

package/src/config.ts

@@ -20,6 +20,22 @@ export interface ChorusConfig {
     dailyRunCap: number;
     defaultFrequency: number;
     defaultMaxFrequency: number;
+    researchTimeoutMs: number;
+    checkIntervalMs: number;
+  };
+  daemon: {
+    enabled: boolean;
+    senses: {
+      inbox: boolean;
+      purposes: boolean;
+      time: boolean;
+    };
+    thinkThreshold: number;
+    pollIntervalMs: number;
+    minSleepMs: number;
+    maxSleepMs: number;
+    quietHoursStart: number;
+    quietHoursEnd: number;
   };
   prayers: {
     enabled: boolean;
@@ -45,6 +61,23 @@ export interface ChorusPluginConfig {
     dailyRunCap?: number;
     defaultFrequency?: number;
     defaultMaxFrequency?: number;
+    researchTimeoutMs?: number;
+    checkIntervalMs?: number;
+  };
+  /** Daemon config */
+  daemon?: {
+    enabled?: boolean;
+    senses?: {
+      inbox?: boolean;
+      purposes?: boolean;
+      time?: boolean;
+    };
+    thinkThreshold?: number;
+    pollIntervalMs?: number;
+    minSleepMs?: number;
+    maxSleepMs?: number;
+    quietHoursStart?: number;
+    quietHoursEnd?: number;
   };
   /** On-chain prayer config */
   prayers?: {
@@ -72,6 +105,22 @@ const DEFAULT_CONFIG: ChorusConfig = {
     dailyRunCap: 50,
     defaultFrequency: 6,
     defaultMaxFrequency: 24,
+    researchTimeoutMs: 300000,
+    checkIntervalMs: 60000,
+  },
+  daemon: {
+    enabled: true,
+    senses: {
+      inbox: true,
+      purposes: true,
+      time: true,
+    },
+    thinkThreshold: 55,
+    pollIntervalMs: 5 * 60 * 1000,
+    minSleepMs: 30 * 1000,
+    maxSleepMs: 10 * 60 * 1000,
+    quietHoursStart: 23,
+    quietHoursEnd: 7,
   },
   prayers: {
     enabled: true,
@@ -146,6 +195,48 @@ export function loadChorusConfig(pluginConfig?: ChorusPluginConfig): ChorusConfi
     if (pluginConfig.purposeResearch.defaultMaxFrequency !== undefined) {
       config.purposeResearch.defaultMaxFrequency = pluginConfig.purposeResearch.defaultMaxFrequency;
     }
+    if (pluginConfig.purposeResearch.researchTimeoutMs !== undefined) {
+      config.purposeResearch.researchTimeoutMs = pluginConfig.purposeResearch.researchTimeoutMs;
+    }
+    if (pluginConfig.purposeResearch.checkIntervalMs !== undefined) {
+      config.purposeResearch.checkIntervalMs = pluginConfig.purposeResearch.checkIntervalMs;
+    }
+  }
+
+  // Daemon
+  if (pluginConfig.daemon) {
+    if (pluginConfig.daemon.enabled !== undefined) {
+      config.daemon.enabled = pluginConfig.daemon.enabled;
+    }
+    if (pluginConfig.daemon.senses) {
+      if (pluginConfig.daemon.senses.inbox !== undefined) {
+        config.daemon.senses.inbox = pluginConfig.daemon.senses.inbox;
+      }
+      if (pluginConfig.daemon.senses.purposes !== undefined) {
+        config.daemon.senses.purposes = pluginConfig.daemon.senses.purposes;
+      }
+      if (pluginConfig.daemon.senses.time !== undefined) {
+        config.daemon.senses.time = pluginConfig.daemon.senses.time;
+      }
+    }
+    if (pluginConfig.daemon.thinkThreshold !== undefined) {
+      config.daemon.thinkThreshold = pluginConfig.daemon.thinkThreshold;
+    }
+    if (pluginConfig.daemon.pollIntervalMs !== undefined) {
+      config.daemon.pollIntervalMs = pluginConfig.daemon.pollIntervalMs;
+    }
+    if (pluginConfig.daemon.minSleepMs !== undefined) {
+      config.daemon.minSleepMs = pluginConfig.daemon.minSleepMs;
+    }
+    if (pluginConfig.daemon.maxSleepMs !== undefined) {
+      config.daemon.maxSleepMs = pluginConfig.daemon.maxSleepMs;
+    }
+    if (pluginConfig.daemon.quietHoursStart !== undefined) {
+      config.daemon.quietHoursStart = pluginConfig.daemon.quietHoursStart;
+    }
+    if (pluginConfig.daemon.quietHoursEnd !== undefined) {
+      config.daemon.quietHoursEnd = pluginConfig.daemon.quietHoursEnd;
+    }
   }
 
   return config;

package/src/daemon.ts

@@ -8,7 +8,7 @@
 import type { PluginLogger } from "openclaw/plugin-sdk";
 import type { Signal, Sense } from "./senses.js";
 import { ALL_SENSES } from "./senses.js";
-import { SalienceFilter, defaultFilter } from "./salience.js";
+import { SalienceFilter } from "./salience.js";
 import { recordExecution, type ChoirExecution } from "./metrics.js";
 
 export interface DaemonConfig {
@@ -55,7 +55,7 @@ export function createDaemon(
   const attentionQueue: AttentionItem[] = [];
   const cleanupFns: (() => void)[] = [];
   
-  let pollInterval: NodeJS.Timeout | null = null;
+  let cycleTimer: NodeJS.Timeout | null = null;
   let running = false;
 
   // Get enabled senses
@@ -146,7 +146,7 @@ export function createDaemon(
 
     try {
       const result = await api.runAgentTurn?.({
-        sessionLabel: "chorus:daemon",
+        sessionLabel: "chorus-daemon",
         message: prompt,
         isolated: true,
         timeoutSeconds: 180,
@@ -240,11 +240,7 @@ export function createDaemon(
       // Start event watchers
       startWatchers();
 
-      // Initial poll
-      pollSenses().catch(err => log.error(`[daemon] Initial poll failed: ${err}`));
-
-      // Periodic polling
-      pollInterval = setInterval(async () => {
+      const runCycle = async (): Promise<void> => {
         if (!running) return;
 
         try {
@@ -253,18 +249,27 @@ export function createDaemon(
         } catch (err) {
           log.error(`[daemon] Cycle error: ${err}`);
         }
-      }, config.pollIntervalMs);
 
-      log.info(`[daemon] 👁️ Active — polling every ${config.pollIntervalMs / 1000}s, threshold: ${config.thinkThreshold}`);
+        if (!running) return;
+        cycleTimer = setTimeout(() => {
+          runCycle().catch(err => log.error(`[daemon] Cycle scheduler error: ${err}`));
+        }, calculateSleepTime());
+      };
+
+      runCycle().catch(err => log.error(`[daemon] Initial cycle failed: ${err}`));
+
+      log.info(
+        `[daemon] 👁️ Active — adaptive sleep ${config.minSleepMs / 1000}s..${config.maxSleepMs / 1000}s, threshold: ${config.thinkThreshold}`
+      );
     },
 
     stop: () => {
       running = false;
       log.info("[daemon] Stopping...");
 
-      if (pollInterval) {
-        clearInterval(pollInterval);
-        pollInterval = null;
+      if (cycleTimer) {
+        clearTimeout(cycleTimer);
+        cycleTimer = null;
       }
 
       for (const cleanup of cleanupFns) {

package/src/delivery.ts

@@ -0,0 +1,121 @@
+import { spawn } from "child_process";
+
+interface DeliverableChoir {
+  name: string;
+  delivers?: boolean;
+}
+
+interface LoggerLike {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+}
+
+function toPlainTextIfNeeded(text: string, channel?: string): string {
+  let deliveryText = text.slice(0, 4000);
+  if (channel !== "imessage") return deliveryText;
+
+  return deliveryText
+    .replace(/\*\*(.+?)\*\*/g, "$1")
+    .replace(/\*(.+?)\*/g, "$1")
+    .replace(/__(.+?)__/g, "$1")
+    .replace(/_(.+?)_/g, "$1")
+    .replace(/`(.+?)`/g, "$1")
+    .replace(/```[\s\S]*?```/g, "")
+    .replace(/^#{1,6}\s+/gm, "")
+    .replace(/^\s*[-*+]\s+/gm, "• ")
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+}
+
+function resolveDeliveryTarget(api: any): { target?: string; channel?: string } {
+  const channels = api?.config?.channels as Record<string, any> | undefined;
+  if (!channels) return {};
+
+  for (const [channel, cfg] of Object.entries(channels)) {
+    if (cfg?.enabled && cfg?.allowFrom?.[0]) {
+      return { target: cfg.allowFrom[0], channel };
+    }
+  }
+
+  return {};
+}
+
+export async function deliverChoirOutput(
+  api: any,
+  choir: DeliverableChoir,
+  text: string,
+  log?: LoggerLike
+): 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}`);
+    return;
+  }
+
+  const args = [
+    "message", "send",
+    "--target", target,
+    "--message", toPlainTextIfNeeded(text, channel),
+  ];
+  if (channel) args.push("--channel", channel);
+
+  await new Promise<void>((resolve) => {
+    try {
+      const child = spawn("openclaw", args, { stdio: ["ignore", "pipe", "pipe"] });
+      let stderr = "";
+      child.stderr.on("data", (d: Buffer) => {
+        if (stderr.length < 1024) stderr += d.toString();
+      });
+
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, 30000);
+
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          log?.info?.(`[chorus] 📨 ${choir.name} output delivered via ${channel || "default"}`);
+        } else {
+          const err = stderr.trim().slice(0, 160);
+          log?.warn?.(`[chorus] ⚠ ${choir.name} delivery failed${err ? `: ${err}` : ""}`);
+        }
+        resolve();
+      });
+
+      child.on("error", (err: any) => {
+        clearTimeout(timer);
+        log?.warn?.(`[chorus] ⚠ ${choir.name} delivery error: ${(err?.message || "").slice(0, 160)}`);
+        resolve();
+      });
+    } catch (err: any) {
+      log?.warn?.(`[chorus] ⚠ ${choir.name} delivery error: ${(err?.message || "").slice(0, 160)}`);
+      resolve();
+    }
+  });
+}

package/src/economics.ts

@@ -0,0 +1,166 @@
+/**
+ * CHORUS Attention Economics — Phase 1: Observe
+ *
+ * Tracks inference cost and value signals per choir/purpose.
+ * No frequency adjustments yet — just measurement.
+ *
+ * Cost: captured from each choir run (tokens × model rate)
+ * Value: attributed from downstream outcomes (calibration wins, alerts acted on, etc.)
+ */
+
+import { existsSync, appendFileSync, readFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+const ECONOMICS_DIR = join(homedir(), ".chorus", "economics");
+
+// Model cost rates (USD per 1K tokens)
+const MODEL_RATES: Record<string, { input: number; output: number }> = {
+  "claude-sonnet-4": { input: 0.003, output: 0.015 },
+  "claude-opus-4": { input: 0.015, output: 0.075 },
+  "claude-haiku-3.5": { input: 0.0008, output: 0.004 },
+  default: { input: 0.003, output: 0.015 }, // assume sonnet
+};
+
+// ── Cost Tracking ────────────────────────────────────────────
+
+export interface RunCost {
+  choirId: string;
+  purposeId?: string;
+  timestamp: string;
+  inputTokens: number;
+  outputTokens: number;
+  model: string;
+  inferenceMs: number;
+  costUsd: number;
+}
+
+function ensureDir(): void {
+  if (!existsSync(ECONOMICS_DIR)) {
+    mkdirSync(ECONOMICS_DIR, { recursive: true });
+  }
+}
+
+export function recordCost(cost: RunCost): void {
+  ensureDir();
+  const line = JSON.stringify(cost) + "\n";
+  appendFileSync(join(ECONOMICS_DIR, "costs.jsonl"), line);
+}
+
+export function estimateCost(
+  inputTokens: number,
+  outputTokens: number,
+  model: string = "default"
+): number {
+  const rate = MODEL_RATES[model] || MODEL_RATES.default;
+  return (inputTokens / 1000) * rate.input + (outputTokens / 1000) * rate.output;
+}
+
+// ── Value Tracking ───────────────────────────────────────────
+
+export type ValueKind =
+  | "thesis_win"       // calibration record: prediction correct
+  | "thesis_save"      // powers caught a flaw → loss avoided
+  | "config_improve"   // virtues change → measurable improvement
+  | "alert_acted"      // archangels alert → human acted
+  | "pnl_attribution"  // research led to profitable trade
+  | "knowledge_cited"; // cherubim insight reused in later decision
+
+export interface ValueEvent {
+  choirId: string;
+  purposeId?: string;
+  timestamp: string;
+  kind: ValueKind;
+  estimatedValueUsd: number;
+  evidence: string;
+}
+
+export function recordValue(event: ValueEvent): void {
+  ensureDir();
+  const line = JSON.stringify(event) + "\n";
+  appendFileSync(join(ECONOMICS_DIR, "value.jsonl"), line);
+}
+
+// ── ROI Calculation ──────────────────────────────────────────
+
+interface ChoirROI {
+  choirId: string;
+  windowDays: number;
+  totalCostUsd: number;
+  totalValueUsd: number;
+  roi: number; // value / cost, or Infinity if cost is 0
+  runCount: number;
+  costPerRun: number;
+}
+
+function readJsonl<T>(filename: string): T[] {
+  const path = join(ECONOMICS_DIR, filename);
+  if (!existsSync(path)) return [];
+  try {
+    return readFileSync(path, "utf-8")
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+
+export function calculateROI(choirId: string, windowDays: number = 7): ChoirROI {
+  const cutoff = Date.now() - windowDays * 86400000;
+
+  const costs = readJsonl<RunCost>("costs.jsonl").filter(
+    (c) => c.choirId === choirId && new Date(c.timestamp).getTime() > cutoff
+  );
+
+  const values = readJsonl<ValueEvent>("value.jsonl").filter(
+    (v) => v.choirId === choirId && new Date(v.timestamp).getTime() > cutoff
+  );
+
+  const totalCost = costs.reduce((sum, c) => sum + c.costUsd, 0);
+  const totalValue = values.reduce((sum, v) => sum + v.estimatedValueUsd, 0);
+
+  return {
+    choirId,
+    windowDays,
+    totalCostUsd: totalCost,
+    totalValueUsd: totalValue,
+    roi: totalCost > 0 ? totalValue / totalCost : values.length > 0 ? Infinity : 0,
+    runCount: costs.length,
+    costPerRun: costs.length > 0 ? totalCost / costs.length : 0,
+  };
+}
+
+export function calculateAllROI(windowDays: number = 7): ChoirROI[] {
+  const choirIds = [
+    "seraphim", "cherubim", "thrones",
+    "dominions", "virtues", "powers",
+    "principalities", "archangels", "angels",
+  ];
+  return choirIds.map((id) => calculateROI(id, windowDays));
+}
+
+// ── Summary ──────────────────────────────────────────────────
+
+export function formatEconomicsSummary(windowDays: number = 7): string {
+  const allROI = calculateAllROI(windowDays);
+  const totalCost = allROI.reduce((s, r) => s + r.totalCostUsd, 0);
+  const totalValue = allROI.reduce((s, r) => s + r.totalValueUsd, 0);
+  const totalRuns = allROI.reduce((s, r) => s + r.runCount, 0);
+
+  const lines = [
+    `Attention Economics — ${windowDays}d window`,
+    "=".repeat(50),
+    "",
+    `Total: ${totalRuns} runs | $${totalCost.toFixed(2)} cost | $${totalValue.toFixed(2)} value | ROI ${totalCost > 0 ? (totalValue / totalCost).toFixed(1) : "N/A"}x`,
+    "",
+    "Per Choir:",
+    ...allROI.map((r) => {
+      const roi = r.totalCostUsd > 0 ? `${r.roi.toFixed(1)}x` : "N/A";
+      return `  ${r.choirId.padEnd(16)} ${r.runCount.toString().padStart(3)} runs  $${r.totalCostUsd.toFixed(2).padStart(6)} cost  $${r.totalValueUsd.toFixed(2).padStart(8)} value  ${roi.padStart(6)} ROI`;
+    }),
+  ];
+
+  return lines.join("\n");
+}