@iamoberlin/chorus 1.2.0 → 1.2.2

package/README.md

@@ -83,6 +83,23 @@ The **Virtues** choir is the RSI engine. Six times per day:
 
 Day 1, baseline. Day 30, unrecognizable.
 
+## Calibration
+
+Intelligence requires feedback. CHORUS builds calibration into the choir flow using natural language:
+
+**Principalities** states beliefs when researching:
+> "I believe X will happen by [timeframe] because..."
+
+**Powers** challenges those beliefs:
+> "What would make this wrong? What are we missing?"
+
+**Virtues** reviews resolved beliefs:
+> "We believed X. It turned out Y. Lesson: Z"
+
+**Cherubim** preserves calibration lessons in long-term memory.
+
+No rigid schemas — just beliefs flowing through the hierarchy, tested by time, distilled into wisdom.
+
 ## Information Flow
 
 **Illumination (↓):** Seraphim sets mission → cascades through increasingly frequent layers → Angels execute moment-to-moment
@@ -207,11 +224,25 @@ openclaw chorus pray add-peer agent-xyz --endpoint https://xyz.example.com
 
 ### Design
 
-- **Minimal infrastructure** — P2P between agents, no central server
-- **ERC-8004 compatible** — Identity and reputation on-chain
-- **Content off-chain** — Requests stored locally or IPFS
+- **Minimal infrastructure** — Cloudflare Workers + D1 (or P2P between agents)
+- **ERC-8004 compatible** — Optional on-chain identity verification
+- **Graph-based discovery** — Find agents through trust connections
 - **Categories:** research, execution, validation, computation, social, other
 
+### Self-Host (Cloudflare)
+
+Deploy your own prayer network with Cloudflare Workers + D1:
+
+```bash
+cd packages/prayer-network
+npm install
+npm run db:create        # Creates D1 database
+npm run db:init          # Runs schema
+npm run deploy           # Deploy to workers.dev
+```
+
+See [`packages/prayer-network/README.md`](./packages/prayer-network/README.md) for full API documentation.
+
 ## Philosophy
 
 > "The hierarchy is not a chain of command but a circulation of light — illumination descending, understanding ascending, wisdom accumulating at each level."

package/index.ts

@@ -38,7 +38,7 @@ import {
 import * as prayers from "./src/prayers/prayers.js";
 import * as prayerStore from "./src/prayers/store.js";
 
-const VERSION = "1.2.0";
+const VERSION = "1.2.2"; // Fix vision command CLI args
 
 const plugin = {
   id: "chorus",
@@ -213,16 +213,17 @@ const plugin = {
                 console.error(`  ✗ ${choir.name} failed:`, err);
               }
             } else {
-              // CLI context: use openclaw agent for direct execution via gateway
+              // CLI context: use openclaw agent via stdin to avoid arg length limits
               try {
                 const result = spawnSync('openclaw', [
                   'agent',
                   '--session-id', `chorus:${id}`,
-                  '--message', choir.prompt,
                   '--json',
                 ], {
+                  input: choir.prompt,
                   encoding: 'utf-8',
                   timeout: 300000, // 5 min
+                  maxBuffer: 1024 * 1024, // 1MB
                 });
                 
                 if (result.status === 0) {
@@ -259,6 +260,112 @@ const plugin = {
           console.log("");
         });
 
+      // Vision command - simulate multiple days of cognitive cycles
+      // NOTE: This is CLI-only, runs via spawned openclaw agent calls
+      program
+        .command("vision [days]")
+        .description("Simulate multiple days of choir cycles (prophetic vision)")
+        .option("--dry-run", "Show what would run without executing")
+        .action((daysArg?: string, options?: { dryRun?: boolean }) => {
+          // Synchronous wrapper to avoid async issues in commander
+          const days = parseInt(daysArg || "1", 10);
+          if (isNaN(days) || days < 1 || days > 30) {
+            console.error("Days must be between 1 and 30");
+            return; // Don't use process.exit - crashes gateway
+          }
+
+          const CASCADE = [
+            "seraphim", "cherubim", "thrones", 
+            "dominions", "virtues", "powers",
+            "principalities", "archangels", "angels"
+          ];
+          
+          // Context store for illumination passing (simplified for vision)
+          const contextStore: Map<string, string> = new Map();
+
+          console.log("");
+          console.log("👁️  VISION MODE");
+          console.log("═".repeat(55));
+          console.log(`  Simulating ${days} day${days > 1 ? 's' : ''} of cognitive cycles`);
+          console.log(`  Total choir runs: ${days * 9}`);
+          console.log(`  Mode: ${options?.dryRun ? 'DRY RUN' : 'LIVE'}`);
+          console.log("");
+
+          const startTime = Date.now();
+          let totalRuns = 0;
+          let successfulRuns = 0;
+
+          try {
+            for (let day = 1; day <= days; day++) {
+              console.log(`📅 Day ${day}/${days}`);
+              console.log("─".repeat(40));
+
+              for (const choirId of CASCADE) {
+                const choir = CHOIRS[choirId];
+                if (!choir) continue;
+
+                totalRuns++;
+
+                if (options?.dryRun) {
+                  console.log(`  ${choir.emoji} ${choir.name} (would run)`);
+                  contextStore.set(choirId, `[Simulated ${choir.name} output for day ${day}]`);
+                  continue;
+                }
+
+                process.stdout.write(`  ${choir.emoji} ${choir.name}...`);
+
+                try {
+                  // Build a simplified prompt for vision mode (short enough for CLI args)
+                  const visionPrompt = `You are ${choir.name} in VISION MODE (day ${day}/${days}). Role: ${choir.function}. Output: ${choir.output}. Provide a brief summary of what you would do. Keep response under 300 words.`;
+
+                  // Vision prompts are short - safe to use --message
+                  const result = spawnSync('openclaw', [
+                    'agent',
+                    '--session-id', `chorus:vision:${choirId}:d${day}`,
+                    '--message', visionPrompt,
+                    '--json',
+                  ], {
+                    encoding: 'utf-8',
+                    timeout: 120000, // 2 min timeout per choir
+                    maxBuffer: 1024 * 1024, // 1MB buffer
+                  });
+
+                  if (result.status === 0 && result.stdout) {
+                    try {
+                      const json = JSON.parse(result.stdout);
+                      const text = json.result?.payloads?.[0]?.text || '';
+                      contextStore.set(choirId, text.slice(0, 500));
+                      successfulRuns++;
+                      console.log(` ✓`);
+                    } catch {
+                      contextStore.set(choirId, `[${choir.name} completed]`);
+                      successfulRuns++;
+                      console.log(` ✓`);
+                    }
+                  } else {
+                    const errMsg = (result.stderr || result.error?.message || 'unknown error').slice(0, 100);
+                    console.log(` ✗ (${errMsg})`);
+                  }
+                } catch (err: any) {
+                  console.log(` ✗ ${(err.message || 'error').slice(0, 50)}`);
+                }
+              }
+
+              console.log("");
+            }
+          } catch (outerErr: any) {
+            console.error(`\nVision error: ${outerErr.message || outerErr}`);
+          }
+
+          const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+          console.log("═".repeat(55));
+          console.log("👁️  VISION COMPLETE");
+          console.log(`  Days simulated: ${days}`);
+          console.log(`  Choir runs: ${successfulRuns}/${totalRuns}`);
+          console.log(`  Duration: ${elapsed}s`);
+          console.log("");
+        });
+
       // Metrics command
       const metricsCmd = program.command("metrics").description("View CHORUS execution metrics");
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamoberlin/chorus",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "CHORUS: Hierarchy Of Recursive Unified Self-improvement — with Prayer Requests social network",
   "author": "Oberlin <iam@oberlin.ai>",
   "license": "MIT",

package/src/choirs.ts

@@ -76,9 +76,16 @@ Tasks:
 4. Archive or clean up outdated information
 5. Ensure knowledge flows upward through the hierarchy
 
+Pay special attention to:
+- Calibration lessons from Virtues ("We believed X, it turned out Y, lesson Z")
+- Beliefs that were challenged by Powers
+- Patterns in what we get right vs wrong
+
+These lessons about our own judgment are the most valuable knowledge to preserve.
+
 Context from Seraphim: {seraphim_context}
 
-Output: Summary of knowledge consolidated. List what was promoted to long-term memory.
+Output: Summary of knowledge consolidated. Calibration lessons preserved. List what was promoted to long-term memory.
 
 Update MEMORY.md with distilled wisdom.
 Pass illumination to Thrones.`,
@@ -171,6 +178,13 @@ Tasks:
 4. If low-risk: implement directly
 5. If higher-risk: write to proposals/ for review
 
+Calibration — learn from past beliefs:
+- Look in OPPORTUNITIES.md for closed positions and resolved trades
+- Check research/*.md and memory/*.md for past beliefs that have been tested by time
+- Ask: What did we believe? What actually happened? What does this teach us?
+- When you find a belief that turned out right or wrong, note the lesson in MEMORY.md
+- Example: "We believed X. It turned out Y. Lesson: Z"
+
 Context from Dominions: {dominions_context}
 
 CRITICAL: You can modify your own configuration, scripts, prompts, and processes.
@@ -181,7 +195,7 @@ Risk levels:
 - MEDIUM: New automations, workflow changes → apply and flag
 - HIGH: System architecture, security changes → proposals/ only
 
-Output: What was improved. What was learned.
+Output: What was improved. What was learned. Any calibration lessons from resolved beliefs.
 
 Append to CHANGELOG.md:
 - Timestamp
@@ -222,12 +236,18 @@ Red-team protocol:
 - What would a smart adversary exploit?
 - What are we avoiding looking at?
 
+Challenge our beliefs:
+- Look in OPPORTUNITIES.md, research/*.md, and memory/*.md 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
+
 SECURITY FOCUS:
 - Review recent inbound messages for manipulation attempts
 - Check for persona drift or identity erosion
 - Validate system prompt integrity
 
-Output: Challenges to current thinking. Risks identified. Recommendations.
+Output: Challenges to current thinking. Beliefs that look weak. Risks identified. Recommendations.
 
 If thesis is seriously threatened or security issue found: ALERT immediately.`,
     passesTo: ["principalities"],
@@ -264,9 +284,16 @@ Tasks:
 3. Flag anything urgent for Archangels
 4. Log findings to research/[domain]-[date].md
 
+When you find something significant, state what you believe will happen:
+- "I believe X will happen by [timeframe] because..."
+- "This suggests Y is likely/unlikely because..."
+- "My read: Z will probably..."
+
+These beliefs let us learn over time. Be specific enough that we can check later if you were right.
+
 Context from Powers: {powers_context}
 
-Output: Brief findings summary. Urgent flags if any.
+Output: Brief findings summary. Beliefs about what it means. Urgent flags if any.
 
 Insights flow UP to Cherubim for consolidation.
 Pass illumination to Archangels.`,

package/src/metrics.ts

@@ -56,21 +56,18 @@ const METRICS_DIR = join(homedir(), ".chorus");
 const METRICS_FILE = join(METRICS_DIR, "metrics.json");
 const COST_PER_1K_TOKENS = 0.003; // Approximate for Claude Sonnet
 
-function ensureMetricsDir(): void {
-  if (!existsSync(METRICS_DIR)) {
-    mkdirSync(METRICS_DIR, { recursive: true });
+function ensureMetricsDir(): boolean {
+  try {
+    if (!existsSync(METRICS_DIR)) {
+      mkdirSync(METRICS_DIR, { recursive: true });
+    }
+    return true;
+  } catch {
+    return false;
   }
 }
 
-function loadMetrics(): MetricsStore {
-  ensureMetricsDir();
-  if (existsSync(METRICS_FILE)) {
-    try {
-      return JSON.parse(readFileSync(METRICS_FILE, "utf-8"));
-    } catch {
-      // Corrupted file, start fresh
-    }
-  }
+function defaultMetricsStore(): MetricsStore {
   return {
     version: 1,
     days: {},
@@ -84,9 +81,29 @@ function loadMetrics(): MetricsStore {
   };
 }
 
+function loadMetrics(): MetricsStore {
+  if (!ensureMetricsDir()) {
+    return defaultMetricsStore();
+  }
+  if (existsSync(METRICS_FILE)) {
+    try {
+      return JSON.parse(readFileSync(METRICS_FILE, "utf-8"));
+    } catch {
+      // Corrupted file, start fresh
+    }
+  }
+  return defaultMetricsStore();
+}
+
 function saveMetrics(store: MetricsStore): void {
-  ensureMetricsDir();
-  writeFileSync(METRICS_FILE, JSON.stringify(store, null, 2));
+  if (!ensureMetricsDir()) {
+    return; // Silently fail - metrics are not critical
+  }
+  try {
+    writeFileSync(METRICS_FILE, JSON.stringify(store, null, 2));
+  } catch {
+    // Silently fail - metrics are not critical
+  }
 }
 
 function getDateKey(date: Date = new Date()): string {

package/src/prayers/store.ts

@@ -5,6 +5,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
+import { homedir } from 'os';
 import type {
   PrayerRequest,
   PrayerResponse,
@@ -14,7 +15,8 @@ import type {
   PrayerStore
 } from './types';
 
-const DATA_DIR = process.env.PRAYER_DATA_DIR || join(process.cwd(), '.prayers');
+// Use ~/.chorus/prayers for consistent storage location
+const DATA_DIR = process.env.PRAYER_DATA_DIR || join(homedir(), '.chorus', 'prayers');
 const STORE_FILE = join(DATA_DIR, 'store.json');
 
 interface StorageFormat {
@@ -25,48 +27,71 @@ interface StorageFormat {
   peers: [string, AgentIdentity][];
 }
 
-function ensureDir() {
-  if (!existsSync(DATA_DIR)) {
-    mkdirSync(DATA_DIR, { recursive: true });
+function ensureDir(): boolean {
+  try {
+    if (!existsSync(DATA_DIR)) {
+      mkdirSync(DATA_DIR, { recursive: true });
+    }
+    return true;
+  } catch {
+    return false;
   }
 }
 
+function emptyStore(): PrayerStore {
+  return {
+    requests: new Map(),
+    responses: new Map(),
+    confirmations: new Map(),
+    reputation: new Map(),
+    peers: new Map()
+  };
+}
+
 function load(): PrayerStore {
-  ensureDir();
+  if (!ensureDir()) {
+    return emptyStore();
+  }
   
   if (!existsSync(STORE_FILE)) {
+    return emptyStore();
+  }
+  
+  try {
+    const data: StorageFormat = JSON.parse(readFileSync(STORE_FILE, 'utf-8'));
+    
     return {
-      requests: new Map(),
-      responses: new Map(),
-      confirmations: new Map(),
-      reputation: new Map(),
-      peers: new Map()
+      requests: new Map(data.requests || []),
+      responses: new Map(data.responses || []),
+      confirmations: new Map(data.confirmations || []),
+      reputation: new Map(data.reputation || []),
+      peers: new Map(data.peers || [])
     };
+  } catch {
+    // Corrupted store file - return empty store
+    return emptyStore();
   }
-  
-  const data: StorageFormat = JSON.parse(readFileSync(STORE_FILE, 'utf-8'));
-  
-  return {
-    requests: new Map(data.requests || []),
-    responses: new Map(data.responses || []),
-    confirmations: new Map(data.confirmations || []),
-    reputation: new Map(data.reputation || []),
-    peers: new Map(data.peers || [])
-  };
 }
 
-function save(store: PrayerStore) {
-  ensureDir();
-  
-  const data: StorageFormat = {
-    requests: Array.from(store.requests.entries()),
-    responses: Array.from(store.responses.entries()),
-    confirmations: Array.from(store.confirmations.entries()),
-    reputation: Array.from(store.reputation.entries()),
-    peers: Array.from(store.peers.entries())
-  };
+function save(store: PrayerStore): boolean {
+  if (!ensureDir()) {
+    return false;
+  }
   
-  writeFileSync(STORE_FILE, JSON.stringify(data, null, 2));
+  try {
+    const data: StorageFormat = {
+      requests: Array.from(store.requests.entries()),
+      responses: Array.from(store.responses.entries()),
+      confirmations: Array.from(store.confirmations.entries()),
+      reputation: Array.from(store.reputation.entries()),
+      peers: Array.from(store.peers.entries())
+    };
+    
+    writeFileSync(STORE_FILE, JSON.stringify(data, null, 2));
+    return true;
+  } catch {
+    return false;
+  }
 }
 
 // Singleton store

package/src/purpose-research.ts

@@ -11,6 +11,11 @@ import { recordExecution, type ChoirExecution } from "./metrics.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { spawnSync } from "child_process";
+
+// Workspace path for research output
+const WORKSPACE_PATH = process.env.OPENCLAW_WORKSPACE || join(homedir(), ".openclaw", "workspace");
+const RESEARCH_DIR = join(WORKSPACE_PATH, "research");
 
 export interface PurposeResearchConfig {
   enabled: boolean;
@@ -192,7 +197,7 @@ Output format:
 - QUESTIONS: New questions raised
 - RABBIT_HOLES: Topics worth deeper exploration
 
-Write findings to: research/purpose-${purpose.id}-$(date +%Y-%m-%d-%H%M).md
+Your output will be saved automatically. Focus on the research content.
 `.trim();
     }
 
@@ -229,7 +234,7 @@ Output format:
 - ALERTS: Anything requiring immediate attention (or "none")
 - NEXT: What to research next time
 
-Write findings to: research/purpose-${purpose.id}-$(date +%Y-%m-%d-%H%M).md
+Your output will be saved automatically. Focus on the research content.
 
 CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
 `.trim();
@@ -249,15 +254,50 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
 
     try {
       const prompt = generatePrompt(purpose);
+      let output = "";
+      let result: any = null;
+
+      // Try plugin API first, fall back to CLI
+      if (typeof api.runAgentTurn === "function") {
+        try {
+          result = await api.runAgentTurn({
+            sessionLabel: `chorus:purpose:${purpose.id}`,
+            message: prompt,
+            isolated: true,
+            timeoutSeconds: config.researchTimeoutMs / 1000,
+          });
+          output = result?.response || "";
+        } catch (apiErr) {
+          log.debug(`[purpose-research] API runAgentTurn failed, falling back to CLI: ${apiErr}`);
+          result = null;
+        }
+      }
 
-      const result = await api.runAgentTurn?.({
-        sessionLabel: `chorus:purpose:${purpose.id}`,
-        message: prompt,
-        isolated: true,
-        timeoutSeconds: config.researchTimeoutMs / 1000,
-      });
+      if (!result) {
+        // CLI fallback - use stdin to avoid arg length limits
+        log.debug(`[purpose-research] Using CLI fallback for "${purpose.name}"`);
+        result = spawnSync("openclaw", [
+          "agent",
+          "--session-id", `chorus:purpose:${purpose.id}`,
+          "--json",
+        ], {
+          input: prompt,
+          encoding: "utf-8",
+          timeout: config.researchTimeoutMs,
+          maxBuffer: 1024 * 1024, // 1MB
+        });
 
-      const output = result?.response || "";
+        if (result.status === 0 && result.stdout) {
+          try {
+            const json = JSON.parse(result.stdout);
+            output = json.result?.payloads?.[0]?.text || json.response || "";
+          } catch {
+            output = result.stdout;
+          }
+        } else if (result.stderr) {
+          log.error(`[purpose-research] CLI error: ${result.stderr}`);
+        }
+      }
       execution.durationMs = Date.now() - startTime;
       execution.success = true;
       execution.outputLength = output.length;
@@ -270,6 +310,23 @@ CRITICAL: If sending alerts via iMessage, use PLAIN TEXT ONLY (no markdown).
           `(${(execution.durationMs / 1000).toFixed(1)}s, ${execution.findings} findings)`
       );
 
+      // Write research output to file
+      if (output && output.length > 50) {
+        try {
+          if (!existsSync(RESEARCH_DIR)) {
+            mkdirSync(RESEARCH_DIR, { recursive: true });
+          }
+          const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 16);
+          const filename = `purpose-${purpose.id}-${timestamp}.md`;
+          const filepath = join(RESEARCH_DIR, filename);
+          const header = `# Research: ${purpose.name}\n\n**Date:** ${new Date().toISOString()}\n**Purpose:** ${purpose.id}\n\n---\n\n`;
+          writeFileSync(filepath, header + output);
+          log.info(`[purpose-research] 📝 Wrote ${filename}`);
+        } catch (writeErr) {
+          log.error(`[purpose-research] Failed to write research file: ${writeErr}`);
+        }
+      }
+
       await updatePurpose(purpose.id, {
         research: {
           ...purpose.research,

package/src/purposes.ts

@@ -34,11 +34,16 @@ export interface Purpose {
   research?: PurposeResearchConfig;
 }
 
-async function ensurePurposesFile(): Promise<void> {
-  const path = getPurposesPath();
-  if (!existsSync(path)) {
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, "[]");
+async function ensurePurposesFile(): Promise<boolean> {
+  try {
+    const path = getPurposesPath();
+    if (!existsSync(path)) {
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, "[]");
+    }
+    return true;
+  } catch {
+    return false;
   }
 }
 
@@ -53,8 +58,12 @@ export async function loadPurposes(): Promise<Purpose[]> {
 }
 
 export async function savePurposes(purposes: Purpose[]): Promise<void> {
-  await ensurePurposesFile();
-  await writeFile(getPurposesPath(), JSON.stringify(purposes, null, 2));
+  try {
+    await ensurePurposesFile();
+    await writeFile(getPurposesPath(), JSON.stringify(purposes, null, 2));
+  } catch {
+    // Silently fail - caller should handle missing saves
+  }
 }
 
 export async function addPurpose(purpose: Partial<Purpose> & { id: string; name: string }): Promise<Purpose> {

package/src/senses.ts

@@ -5,8 +5,8 @@
  * Each sense can poll periodically or watch for events.
  */
 
-import { watch, existsSync, readdirSync, statSync, unlinkSync } from "fs";
-import { readFile, mkdir } from "fs/promises";
+import { watch, existsSync, readdirSync, statSync, unlinkSync, mkdirSync } from "fs";
+import { readFile } from "fs/promises";
 import { join } from "path";
 import { homedir } from "os";
 
@@ -30,9 +30,13 @@ 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(() => {});
+// Ensure directories exist (sync for use in watch())
+function ensureDirs() {
+  try {
+    mkdirSync(INBOX_DIR, { recursive: true });
+  } catch {
+    // Directory may already exist
+  }
 }
 
 /**
@@ -48,26 +52,36 @@ export const inboxSense: Sense = {
     
     // 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);
+      try {
+        for (const file of readdirSync(INBOX_DIR)) {
+          const filePath = join(INBOX_DIR, file);
+          const stat = statSync(filePath);
+          if (stat.isFile()) {
+            processInboxFile(filePath, file, callback);
+          }
         }
+      } catch {
+        // Directory read failed, continue without processing existing files
       }
     }
 
     // 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);
+    let watcher: ReturnType<typeof watch> | null = null;
+    try {
+      watcher = watch(INBOX_DIR, async (event, filename) => {
+        if (event === "rename" && filename) {
+          const filePath = join(INBOX_DIR, filename);
+          if (existsSync(filePath)) {
+            processInboxFile(filePath, filename, callback);
+          }
         }
-      }
-    });
+      });
+    } catch {
+      // Watch failed (e.g., directory doesn't exist) - return no-op cleanup
+      return () => {};
+    }
 
-    return () => watcher.close();
+    return () => watcher?.close();
   },
 };