@iamoberlin/chorus 2.1.0 → 2.2.1

package/README.md

@@ -280,7 +280,7 @@ When `autonomous: false` (default), all prayer chain interactions require explic
 - **TypeScript client** — wraps Anchor IDL with PDA derivation helpers
 - **Anchor events** — `PrayerPosted`, `PrayerAnswered`, `PrayerConfirmed`, `PrayerClaimed`, `PrayerCancelled` for off-chain indexing
 - **Local text cache** — CLI stores full text in `.prayer-texts.json` for display
-- **Program ID:** `DZuj1ZcX4H6THBSgW4GhKA7SbZNXtPDE5xPkW2jN53PQ`
+- **Program ID:** `Af61jGnh2AceK3E8FAxCh9j7Jt6JWtJz6PUtbciDjVJS`
 
 ## Philosophy
 

package/idl/chorus_prayers.json

@@ -1,5 +1,5 @@
 {
-  "address": "DZuj1ZcX4H6THBSgW4GhKA7SbZNXtPDE5xPkW2jN53PQ",
+  "address": "Af61jGnh2AceK3E8FAxCh9j7Jt6JWtJz6PUtbciDjVJS",
   "metadata": {
     "name": "chorus_prayers",
     "version": "0.1.0",

package/index.ts

@@ -11,7 +11,7 @@ import { spawnSync } from "child_process";
 import { loadChorusConfig, type ChorusPluginConfig } from "./src/config.js";
 import { createSecurityHooks } from "./src/security.js";
 import { createChoirScheduler } from "./src/scheduler.js";
-import { CHOIRS, formatFrequency } from "./src/choirs.js";
+import { CHOIRS, formatFrequency, CASCADE_ORDER } from "./src/choirs.js";
 import {
   getTodayMetrics,
   getMetricsForDate,
@@ -102,6 +102,96 @@ const plugin = {
       api.logger.info("[chorus] Purpose research disabled");
     }
 
+    // Helper: resolve {choir_context} placeholders using a context store
+    function resolvePrompt(choir: typeof CHOIRS[string], ctxStore: Map<string, string>): string {
+      let prompt = choir.prompt;
+      for (const upstreamId of choir.receivesFrom) {
+        const placeholder = `{${upstreamId}_context}`;
+        const ctx = ctxStore.get(upstreamId);
+        prompt = prompt.replace(placeholder, ctx || `(no prior ${upstreamId} output)`);
+      }
+      return prompt;
+    }
+
+    // Helper: extract text from openclaw agent JSON output
+    function extractAgentText(stdout: string): string {
+      // Find the last top-level JSON object (skip plugin log noise)
+      for (let i = stdout.length - 1; i >= 0; i--) {
+        if (stdout[i] === '{') {
+          try {
+            const json = JSON.parse(stdout.slice(i));
+            const payloads = json.result?.payloads || [];
+            const texts = payloads.map((p: any) => p?.text || '').filter(Boolean);
+            if (texts.length > 0) return texts[texts.length - 1];
+            return json.result?.text || json.response || json.content || '';
+          } catch { /* keep searching */ }
+        }
+      }
+      return '';
+    }
+
+    // Deliver choir output to user via OpenClaw messaging (channel-agnostic)
+    // Reads target from OpenClaw config (channels.*.allowFrom) — no hardcoded PII
+    function deliverIfNeeded(choir: typeof CHOIRS[string], text: string): void {
+      if (!choir.delivers || !text || text === 'HEARTBEAT_OK' || text === 'NO_REPLY') return;
+
+      // Resolve delivery target from OpenClaw channel config
+      const channels = api.config?.channels as Record<string, any> | undefined;
+      let target: string | undefined;
+      let channel: string | undefined;
+
+      if (channels) {
+        for (const [ch, cfg] of Object.entries(channels)) {
+          if (cfg?.enabled && cfg?.allowFrom?.[0]) {
+            target = cfg.allowFrom[0];
+            channel = ch;
+            break;
+          }
+        }
+      }
+
+      if (!target) {
+        console.log(`    ⚠ No delivery target found in OpenClaw config`);
+        return;
+      }
+
+      // Strip markdown for channels that don't support it
+      let deliveryText = text.slice(0, 4000);
+      if (channel === 'imessage') {
+        deliveryText = deliveryText
+          .replace(/\*\*(.+?)\*\*/g, '$1')    // bold
+          .replace(/\*(.+?)\*/g, '$1')          // italic
+          .replace(/__(.+?)__/g, '$1')          // bold alt
+          .replace(/_(.+?)_/g, '$1')            // italic alt
+          .replace(/`(.+?)`/g, '$1')            // inline code
+          .replace(/```[\s\S]*?```/g, '')       // code blocks
+          .replace(/^#{1,6}\s+/gm, '')          // headers
+          .replace(/^\s*[-*+]\s+/gm, '• ')     // bullet lists
+          .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1'); // links
+      }
+
+      try {
+        const args = [
+          'message', 'send',
+          '--target', target,
+          '--message', deliveryText,
+        ];
+        if (channel) args.push('--channel', channel);
+
+        const deliveryResult = spawnSync('openclaw', args, {
+          encoding: 'utf-8',
+          timeout: 30000,
+        });
+        if (deliveryResult.status === 0) {
+          console.log(`    📨 Delivered to user via ${channel || 'default'}`);
+        } else {
+          console.log(`    ⚠ Delivery failed: ${(deliveryResult.stderr || '').slice(0, 80)}`);
+        }
+      } catch (err: any) {
+        console.log(`    ⚠ Delivery error: ${(err.message || '').slice(0, 80)}`);
+      }
+    }
+
     // Register CLI
     api.registerCli((ctx) => {
       const program = ctx.program.command("chorus").description("CHORUS Nine Choirs management");
@@ -187,6 +277,8 @@ const plugin = {
             }
           }
 
+          const runCtxStore: Map<string, string> = new Map();
+
           console.log("");
           if (!choirId) {
             console.log("🎵 Running all Nine Choirs in cascade order...");
@@ -198,10 +290,11 @@ const plugin = {
             if (!choir) continue;
             
             console.log(`Running ${choir.name}...`);
+            const prompt = resolvePrompt(choir, runCtxStore);
           
             // Preview mode - just show the prompt
             if (options?.preview) {
-              console.log(`  Prompt: ${choir.prompt.slice(0, 100)}...`);
+              console.log(`  Prompt: ${prompt.slice(0, 100)}...`);
               continue;
             }
 
@@ -210,17 +303,19 @@ const plugin = {
               try {
                 const result = await api.runAgentTurn({
                   sessionLabel: `chorus:${id}`,
-                  message: choir.prompt,
+                  message: prompt,
                   isolated: true,
                   timeoutSeconds: 300,
                 });
                 const text = result?.text || result?.payloads?.[0]?.text || '';
                 const duration = result?.meta?.durationMs || 0;
+                runCtxStore.set(id, text.slice(0, 2000));
                 console.log(`  ✓ ${choir.name} complete (${(duration/1000).toFixed(1)}s)`);
                 if (text) {
                   const preview = text.slice(0, 150).replace(/\n/g, ' ');
                   console.log(`    ${preview}${text.length > 150 ? '...' : ''}`);
                 }
+                deliverIfNeeded(choir, text);
               } catch (err) {
                 console.error(`  ✗ ${choir.name} failed:`, err);
               }
@@ -230,7 +325,7 @@ const plugin = {
                 const result = spawnSync('openclaw', [
                   'agent',
                   '--session-id', `chorus:${id}`,
-                  '--message', choir.prompt,
+                  '--message', prompt,
                   '--json',
                 ], {
                   encoding: 'utf-8',
@@ -239,22 +334,14 @@ const plugin = {
                 });
                 
                 if (result.status === 0) {
-                  try {
-                    // Extract JSON from output (may have plugin logs before it)
-                    const stdout = result.stdout || '';
-                    const jsonStart = stdout.indexOf('{');
-                    const jsonStr = jsonStart >= 0 ? stdout.slice(jsonStart) : '{}';
-                    const json = JSON.parse(jsonStr);
-                    const text = json.result?.payloads?.[0]?.text || '';
-                    const duration = json.result?.meta?.durationMs || 0;
-                    console.log(`  ✓ ${choir.name} complete (${(duration/1000).toFixed(1)}s)`);
-                    if (text) {
-                      const preview = text.slice(0, 150).replace(/\n/g, ' ');
-                      console.log(`    ${preview}${text.length > 150 ? '...' : ''}`);
-                    }
-                  } catch (parseErr) {
-                    console.log(`  ✓ ${choir.name} complete (parse error: ${parseErr})`);
+                  const text = extractAgentText(result.stdout || '');
+                  runCtxStore.set(id, text.slice(0, 2000));
+                  console.log(`  ✓ ${choir.name} complete`);
+                  if (text) {
+                    const preview = text.slice(0, 150).replace(/\n/g, ' ');
+                    console.log(`    ${preview}${text.length > 150 ? '...' : ''}`);
                   }
+                  deliverIfNeeded(choir, text);
                 } else {
                   const errMsg = result.stderr || result.stdout || 'Unknown error';
                   if (errMsg.includes('ECONNREFUSED') || errMsg.includes('connect')) {
@@ -271,7 +358,7 @@ const plugin = {
 
           console.log("");
           if (!choirId) {
-            console.log("🎵 All choirs scheduled.");
+            console.log("🎵 All choirs complete.");
           }
           console.log("");
         });
@@ -348,10 +435,13 @@ const plugin = {
                         const jsonStr = jsonStart >= 0 ? stdout.slice(jsonStart) : '{}';
                         const json = JSON.parse(jsonStr);
                         const text = json.result?.payloads?.[0]?.text || '';
+                        contextStore.set(choirId, text.slice(0, 500));
                         contextStore.set(`${choirId}:d${day}`, text.slice(0, 500));
                         console.log(` ✓ (dry)`);
                       } catch {
-                        contextStore.set(`${choirId}:d${day}`, `[${choir.name} would run]`);
+                        const fallback = `[${choir.name} would run]`;
+                        contextStore.set(choirId, fallback);
+                        contextStore.set(`${choirId}:d${day}`, fallback);
                         console.log(` ✓ (dry)`);
                       }
                     } else {
@@ -366,11 +456,14 @@ const plugin = {
                 process.stdout.write(`  ${choir.emoji} ${choir.name}...`);
 
                 try {
+                  // Resolve context from upstream choirs
+                  const prompt = resolvePrompt(choir, contextStore);
+
                   // Run the REAL choir with full tool access via direct agent call
                   const result = spawnSync('openclaw', [
                     'agent',
                     '--session-id', `chorus:vision:${choirId}:d${day}`,
-                    '--message', choir.prompt,
+                    '--message', prompt,
                     '--json',
                   ], {
                     encoding: 'utf-8',
@@ -382,16 +475,19 @@ const plugin = {
                     // Parse the agent response (extract JSON from output)
                     try {
                       const stdout = result.stdout || '';
-                      const jsonStart = stdout.indexOf('{');
-                      const jsonStr = jsonStart >= 0 ? stdout.slice(jsonStart) : '{}';
-                      const json = JSON.parse(jsonStr);
-                      const text = json.result?.payloads?.[0]?.text || '';
-                      const duration = json.result?.meta?.durationMs || 0;
-                      contextStore.set(`${choirId}:d${day}`, text.slice(0, 2000)); // Keep 2KB of response
+                      const text = extractAgentText(stdout);
+                      // Store by both choirId (for resolvePrompt) and choirId:dN (for summary)
+                      contextStore.set(choirId, text.slice(0, 2000));
+                      contextStore.set(`${choirId}:d${day}`, text.slice(0, 2000));
                       successfulRuns++;
-                      console.log(` ✓ (${(duration/1000).toFixed(1)}s)`);
+                      console.log(` ✓`);
+
+                      // Deliver output to user via OpenClaw messaging if choir is marked for delivery
+                      deliverIfNeeded(choir, text);
                     } catch {
-                      contextStore.set(`${choirId}:d${day}`, result.stdout?.slice(-2000) || `[${choir.name} completed]`);
+                      const fallback = result.stdout?.slice(-2000) || `[${choir.name} completed]`;
+                      contextStore.set(choirId, fallback);
+                      contextStore.set(`${choirId}:d${day}`, fallback);
                       successfulRuns++;
                       console.log(` ✓`);
                     }

package/openclaw.plugin.json

@@ -2,11 +2,17 @@
   "id": "chorus",
   "name": "CHORUS",
   "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement",
-  "version": "1.3.4",
+  "version": "2.2.1",
   "author": "Oberlin",
   "homepage": "https://chorus.oberlin.ai",
   "repository": "https://github.com/iamoberlin/chorus",
-  "keywords": ["cognitive-architecture", "rsi", "self-improvement", "nine-choirs", "purposes"],
+  "keywords": [
+    "cognitive-architecture",
+    "rsi",
+    "self-improvement",
+    "nine-choirs",
+    "purposes"
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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

package/src/choirs.ts

@@ -19,6 +19,7 @@ export interface Choir {
   prompt: string;
   passesTo: string[]; // Downstream choirs that receive illumination
   receivesFrom: string[]; // Upstream choirs that provide context
+  delivers?: boolean; // If true, output should be delivered to the user via OpenClaw messaging
 }
 
 export const CHOIRS: Record<string, Choir> = {
@@ -337,14 +338,16 @@ Pass illumination to Archangels.`,
     intervalMinutes: 80, // Every ~80 minutes
     function: "Briefings and alerts",
     output: "Messages to human",
+    delivers: true, // Output routed to user via OpenClaw messaging
     prompt: `You are ARCHANGELS — the Herald.
 
-Your role: Deliver important messages and briefings.
+Your role: Produce briefings and deliver them to Brandon via iMessage.
 
 Briefing types:
-- Morning: Weather, calendar, overnight developments, today's priorities
-- Evening: What was accomplished, what needs attention tomorrow
+- 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
 - Alert: Time-sensitive information requiring attention
+- Update: Regular position/market status when conditions change
 
 Alert criteria (send immediately):
 - Position thesis challenged
@@ -354,12 +357,14 @@ Alert criteria (send immediately):
 
 Context from Principalities: {principalities_context}
 
-Rules:
-- Be concise — headlines, not essays
-- Only alert if it's actually important
-- Late night (11pm-7am): Only truly urgent alerts
+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.
+- If nothing is urgent, still produce a status update.
+- During quiet hours (11 PM - 7 AM ET), only deliver truly urgent alerts.
 
-Output: Briefing or alert message to deliver.`,
+Output: Produce the briefing as your response. Delivery is handled by the infrastructure — just output the content.`,
     passesTo: ["angels"],
     receivesFrom: ["principalities"],
   },

package/src/prayers/solana.ts

@@ -27,7 +27,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 // Program ID (deployed to devnet)
-export const PROGRAM_ID = new PublicKey("DZuj1ZcX4H6THBSgW4GhKA7SbZNXtPDE5xPkW2jN53PQ");
+export const PROGRAM_ID = new PublicKey("Af61jGnh2AceK3E8FAxCh9j7Jt6JWtJz6PUtbciDjVJS");
 
 // Max plaintext size that fits in a Solana transaction after encryption overhead
 // Encrypted blob = plaintext + 40 bytes (24 nonce + 16 Poly1305 tag)

package/src/scheduler.ts

@@ -14,6 +14,17 @@ import { join } from "path";
 import { homedir } from "os";
 import { spawn } from "child_process";
 
+// Type for the plugin API's runAgentTurn method
+interface AgentTurnResult {
+  text?: string;
+  payloads?: Array<{ text?: string; mediaUrl?: string | null }>;
+  meta?: { durationMs?: number };
+}
+
+// ── Delivery ─────────────────────────────────────────────────
+// Choir agents handle their own delivery via OpenClaw messaging tools.
+// The scheduler's job is execution and scheduling — not routing messages.
+
 interface ChoirContext {
   choirId: string;
   output: string;
@@ -95,6 +106,52 @@ export function createChoirScheduler(
   // Load persisted state instead of starting fresh
   const runState = loadRunState(log);
 
+  // CLI fallback for executing choirs when plugin API is unavailable
+  async function executeChoirViaCli(choir: Choir, prompt: string): Promise<string> {
+    const result = await new Promise<{ status: number | null; stdout: string; stderr: string }>((resolve) => {
+      const child = spawn('openclaw', [
+        'agent',
+        '--session-id', `chorus:${choir.id}`,
+        '--message', prompt,
+        '--json',
+      ], { stdio: ['pipe', 'pipe', 'pipe'] });
+
+      let stdout = '';
+      let stderr = '';
+      const maxBuffer = 1024 * 1024;
+      child.stdout.on('data', (d: Buffer) => { if (stdout.length < maxBuffer) stdout += d.toString(); });
+      child.stderr.on('data', (d: Buffer) => { if (stderr.length < maxBuffer) stderr += d.toString(); });
+
+      const timer = setTimeout(() => { child.kill('SIGTERM'); }, 300000); // 5 min
+      child.on('close', (code) => { clearTimeout(timer); resolve({ status: code, stdout, stderr }); });
+      child.on('error', (err) => { clearTimeout(timer); resolve({ status: 1, stdout: '', stderr: String(err) }); });
+    });
+
+    if (result.status === 0 && result.stdout) {
+      const stdout = result.stdout;
+      // Find the last top-level JSON object (skip plugin log noise)
+      for (let i = stdout.length - 1; i >= 0; i--) {
+        if (stdout[i] === '{') {
+          try {
+            const parsed = JSON.parse(stdout.slice(i));
+            return parsed.response ||
+              parsed.content ||
+              parsed.result?.payloads?.slice(-1)?.[0]?.text ||
+              parsed.result?.text ||
+              (typeof parsed.result === "string" ? parsed.result : null) ||
+              stdout;
+          } catch { /* keep searching */ }
+        }
+      }
+      return stdout;
+    }
+
+    if (result.stderr) {
+      log.warn(`[chorus] ${choir.name} CLI stderr: ${result.stderr.slice(0, 200)}`);
+    }
+    return "(no response)";
+  }
+
   // Build the prompt with context injected
   function buildPrompt(choir: Choir): string {
     let prompt = choir.prompt;
@@ -110,7 +167,7 @@ export function createChoirScheduler(
     return prompt;
   }
 
-  // Execute a choir using openclaw agent CLI
+  // Execute a choir using the plugin API (fast, in-process) with CLI fallback
   async function executeChoir(choir: Choir): Promise<void> {
     const state = runState.get(choir.id) || { runCount: 0 };
     const startTime = Date.now();
@@ -127,49 +184,40 @@ export function createChoirScheduler(
 
     try {
       const prompt = buildPrompt(choir);
+      let output = "(no response)";
 
-      // Use openclaw agent CLI (async to avoid blocking event loop)
-      const result = await new Promise<{ status: number | null; stdout: string; stderr: string }>((resolve) => {
-        const child = spawn('openclaw', [
-          'agent',
-          '--session-id', `chorus:${choir.id}`,
-          '--message', prompt,
-          '--json',
-        ], { stdio: ['pipe', 'pipe', 'pipe'] });
-
-        let stdout = '';
-        let stderr = '';
-        const maxBuffer = 1024 * 1024;
-        child.stdout.on('data', (d: Buffer) => { if (stdout.length < maxBuffer) stdout += d.toString(); });
-        child.stderr.on('data', (d: Buffer) => { if (stderr.length < maxBuffer) stderr += d.toString(); });
-
-        const timer = setTimeout(() => { child.kill('SIGTERM'); }, 300000); // 5 min
-        child.on('close', (code) => { clearTimeout(timer); resolve({ status: code, stdout, stderr }); });
-        child.on('error', (err) => { clearTimeout(timer); resolve({ status: 1, stdout: '', stderr: String(err) }); });
-      });
+      // Prefer plugin API (in-process, no CLI spawn overhead)
+      if (typeof api.runAgentTurn === 'function') {
+        try {
+          const result: AgentTurnResult = await api.runAgentTurn({
+            sessionLabel: `chorus:${choir.id}`,
+            message: prompt,
+            isolated: true,
+            timeoutSeconds: 300,
+          });
 
-      let output = "(no response)";
+          // Extract text from payloads — concatenate all payload texts
+          const payloadTexts = (result?.payloads || [])
+            .map((p: any) => p?.text || '')
+            .filter((t: string) => t.length > 0);
 
-      if (result.status === 0 && result.stdout) {
-        // Extract JSON from output (may have plugin logs before it)
-        const stdout = result.stdout;
-        const jsonStart = stdout.indexOf('{');
-        if (jsonStart >= 0) {
-          try {
-            const parsed = JSON.parse(stdout.slice(jsonStart));
-            output = parsed.response || parsed.content || stdout;
-          } catch {
-            output = stdout;
+          if (payloadTexts.length > 0) {
+            // Use the last substantive payload (earlier ones are often thinking-out-loud)
+            output = payloadTexts[payloadTexts.length - 1];
+          } else if (result?.text) {
+            output = result.text;
           }
-        } else {
-          output = stdout;
+        } catch (apiErr) {
+          log.warn(`[chorus] API runAgentTurn failed for ${choir.name}, falling back to CLI: ${apiErr}`);
+          output = await executeChoirViaCli(choir, prompt);
         }
-      } else if (result.stderr) {
-        log.warn(`[chorus] ${choir.name} stderr: ${result.stderr.slice(0, 200)}`);
+      } else {
+        // Fallback: spawn CLI process
+        output = await executeChoirViaCli(choir, prompt);
       }
 
       execution.durationMs = Date.now() - startTime;
-      execution.success = result.status === 0;
+      execution.success = output !== "(no response)";
       execution.outputLength = output.length;
       execution.tokensUsed = estimateTokens(output);
 
@@ -197,6 +245,68 @@ export function createChoirScheduler(
 
       log.info(`[chorus] ${choir.emoji} ${choir.name} completed (${(execution.durationMs/1000).toFixed(1)}s)`);
 
+      // Deliver output to user via OpenClaw messaging if choir is marked for delivery
+      // Reads target from OpenClaw config (channels.*.allowFrom) — no hardcoded PII
+      if (choir.delivers && output && output !== "(no response)" && output !== "HEARTBEAT_OK" && output !== "NO_REPLY") {
+        const channels = api.config?.channels as Record<string, any> | undefined;
+        let target: string | undefined;
+        let channel: string | undefined;
+
+        if (channels) {
+          for (const [ch, cfg] of Object.entries(channels)) {
+            if (cfg?.enabled && cfg?.allowFrom?.[0]) {
+              target = cfg.allowFrom[0];
+              channel = ch;
+              break;
+            }
+          }
+        }
+
+        if (target) {
+          // Strip markdown for channels that don't support it
+          let deliveryText = output.slice(0, 4000);
+          if (channel === 'imessage') {
+            deliveryText = deliveryText
+              .replace(/\*\*(.+?)\*\*/g, '$1')    // bold
+              .replace(/\*(.+?)\*/g, '$1')          // italic
+              .replace(/__(.+?)__/g, '$1')          // bold alt
+              .replace(/_(.+?)_/g, '$1')            // italic alt
+              .replace(/`(.+?)`/g, '$1')            // inline code
+              .replace(/```[\s\S]*?```/g, '')       // code blocks
+              .replace(/^#{1,6}\s+/gm, '')          // headers
+              .replace(/^\s*[-*+]\s+/gm, '• ')     // bullet lists
+              .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1'); // links
+          }
+
+          try {
+            const args = [
+              'message', 'send',
+              '--target', target,
+              '--message', deliveryText,
+            ];
+            if (channel) args.push('--channel', channel);
+
+            const deliveryProc = spawn('openclaw', args, { stdio: ['pipe', 'pipe', 'pipe'] });
+
+            deliveryProc.on('close', (code) => {
+              if (code === 0) {
+                log.info(`[chorus] 📨 ${choir.name} output delivered via ${channel || 'default'}`);
+              } else {
+                log.warn(`[chorus] ⚠ ${choir.name} delivery failed (exit ${code})`);
+              }
+            });
+
+            deliveryProc.on('error', (err) => {
+              log.warn(`[chorus] ⚠ ${choir.name} delivery error: ${err.message}`);
+            });
+          } catch (deliveryErr) {
+            log.warn(`[chorus] ⚠ ${choir.name} delivery error: ${deliveryErr}`);
+          }
+        } else {
+          log.warn(`[chorus] ⚠ No delivery target found in OpenClaw config for ${choir.name}`);
+        }
+      }
+
       // Log illumination flow
       if (choir.passesTo.length > 0) {
         log.debug(`[chorus] Illumination ready for: ${choir.passesTo.join(", ")}`);