@iamoberlin/chorus 2.0.0 → 2.2.0

package/src/choirs.ts

@@ -339,12 +339,13 @@ Pass illumination to Archangels.`,
     output: "Messages to human",
     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 +355,15 @@ 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.
+- DELIVER your briefing by sending it to Brandon via iMessage. You have messaging tools — use them.
 
-Output: Briefing or alert message to deliver.`,
+Output: Produce the briefing, then send it to Brandon via iMessage.`,
     passesTo: ["angels"],
     receivesFrom: ["principalities"],
   },

package/src/prayers/cli.ts

@@ -1,24 +1,30 @@
 #!/usr/bin/env npx tsx
 /**
- * Prayer Chain — On-Chain CLI
+ * Prayer Chain — On-Chain CLI (Private by Default)
  * 
- * Human-in-the-loop commands for the Solana prayer chain.
- * Choirs suggest prayers; humans approve and send them on-chain.
+ * All prayers are end-to-end encrypted. Only the asker and claimer
+ * can read prayer content and answers.
+ * 
+ * Supports multi-claimer collaboration: prayers can accept 1-10 agents.
+ * Bounty splits equally among all claimers on confirm.
  * 
  * Usage:
- *   chorus pray post "What is the current SOFR rate?" --type knowledge --bounty 0.01
+ *   chorus pray post "What is the current SOFR rate?" --type knowledge --bounty 0.01 --claimers 3
  *   chorus pray list
  *   chorus pray show <id>
+ *   chorus pray claims <id>                           # List all claims for a prayer
  *   chorus pray claim <id>
- *   chorus pray answer <id> "SOFR is 4.55%, down 2bps this week"
+ *   chorus pray deliver <id> [--claimer <wallet>]     # Deliver to one or all claimers
+ *   chorus pray answer <id> "SOFR is 4.55%"
  *   chorus pray confirm <id>
  *   chorus pray cancel <id>
- *   chorus pray agent                    # Show my on-chain agent
- *   chorus pray register "oberlin" "macro analysis, research"
- *   chorus pray chain                    # Show prayer chain stats
+ *   chorus pray unclaim <id> [--claimer <wallet>]     # Unclaim own or expired claim
+ *   chorus pray agent                                 # Show my on-chain agent
+ *   chorus pray register "oberlin" "macro analysis"   # Register (auto-derives encryption key)
+ *   chorus pray chain                                 # Show prayer chain stats
  */
 
-import { ChorusPrayerClient, PrayerType, getPrayerChainPDA, getAgentPDA, getPrayerPDA } from "./solana.js";
+import { ChorusPrayerClient, PrayerType, PrayerAccount, ClaimAccount, getPrayerChainPDA, getAgentPDA, getPrayerPDA, getClaimPDA } from "./solana.js";
 import { PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
 import { createHash } from "crypto";
 import * as fs from "fs";
@@ -28,7 +34,6 @@ import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
-// Default to localhost; override with SOLANA_RPC_URL env
 const RPC_URL = process.env.SOLANA_RPC_URL || "http://localhost:8899";
 
 // ── Local text store (off-chain content cache) ────────────
@@ -77,21 +82,6 @@ function getClient(): ChorusPrayerClient {
   return ChorusPrayerClient.fromDefaultKeypair(RPC_URL);
 }
 
-function parsePrayerType(t: string): { [key: string]: object } {
-  const types: Record<string, object> = {
-    knowledge: { knowledge: {} },
-    compute: { compute: {} },
-    review: { review: {} },
-    signal: { signal: {} },
-    collaboration: { collaboration: {} },
-  };
-  const normalized = t.toLowerCase();
-  if (!types[normalized]) {
-    throw new Error(`Unknown prayer type: ${t}. Valid: ${Object.keys(types).join(", ")}`);
-  }
-  return types[normalized];
-}
-
 function formatStatus(status: any): string {
   if (typeof status === "object") {
     return Object.keys(status)[0].toUpperCase();
@@ -122,6 +112,17 @@ function shortKey(key: PublicKey): string {
   return `${s.slice(0, 4)}...${s.slice(-4)}`;
 }
 
+function formatEncryptionKey(key: number[]): string {
+  const allZero = key.every(b => b === 0);
+  if (allZero) return "(none)";
+  return Buffer.from(key).toString("hex").slice(0, 16) + "…";
+}
+
+function getArgValue(flag: string): string | null {
+  const idx = args.indexOf(flag);
+  return idx > -1 ? args[idx + 1] || null : null;
+}
+
 const args = process.argv.slice(2);
 const command = args[0];
 
@@ -138,13 +139,14 @@ async function main() {
         return;
       }
       console.log("");
-      console.log("⛓️  Prayer Chain");
+      console.log("⛓️  Prayer Chain (Private by Default)");
       console.log("═".repeat(40));
       console.log(`  Authority:      ${shortKey(chain.authority)}`);
       console.log(`  Total Prayers:  ${chain.totalPrayers}`);
       console.log(`  Total Answered: ${chain.totalAnswered}`);
       console.log(`  Total Agents:   ${chain.totalAgents}`);
       console.log(`  RPC:            ${RPC_URL}`);
+      console.log(`  Encryption:     X25519 + XSalsa20-Poly1305`);
       console.log("");
       break;
     }
@@ -173,9 +175,12 @@ async function main() {
         process.exit(1);
       }
       console.log(`\n🤖 Registering agent "${name}"...`);
+      console.log(`  🔐 Deriving X25519 encryption key from wallet...`);
+      const encKey = client.getEncryptionPublicKey();
+      console.log(`  Encryption key: ${Buffer.from(encKey).toString("hex").slice(0, 16)}…`);
       try {
         const tx = await client.registerAgent(name, skills);
-        console.log(`  ✓ Registered (tx: ${tx.slice(0, 16)}...)`);
+        console.log(`  ✓ Registered with E2E encryption (tx: ${tx.slice(0, 16)}...)`);
       } catch (err: any) {
         if (err.message?.includes("already in use")) {
           console.log("  Already registered.");
@@ -198,14 +203,15 @@ async function main() {
       console.log("");
       console.log("🤖 Agent");
       console.log("═".repeat(40));
-      console.log(`  Wallet:          ${shortKey(agent.wallet)}`);
-      console.log(`  Name:            ${agent.name}`);
-      console.log(`  Skills:          ${agent.skills}`);
-      console.log(`  Reputation:      ${agent.reputation}`);
-      console.log(`  Prayers Posted:  ${agent.prayersPosted}`);
+      console.log(`  Wallet:           ${shortKey(agent.wallet)}`);
+      console.log(`  Name:             ${agent.name}`);
+      console.log(`  Skills:           ${agent.skills}`);
+      console.log(`  🔐 Encryption:    ${formatEncryptionKey(agent.encryptionKey)}`);
+      console.log(`  Reputation:       ${agent.reputation}`);
+      console.log(`  Prayers Posted:   ${agent.prayersPosted}`);
       console.log(`  Prayers Answered: ${agent.prayersAnswered}`);
       console.log(`  Prayers Confirmed: ${agent.prayersConfirmed}`);
-      console.log(`  Registered:      ${formatTime(agent.registeredAt)}`);
+      console.log(`  Registered:       ${formatTime(agent.registeredAt)}`);
       console.log("");
       break;
     }
@@ -213,34 +219,35 @@ async function main() {
     case "post": {
       const content = args[1];
       if (!content) {
-        console.error('Usage: post "<content>" [--type knowledge] [--bounty 0.01] [--ttl 86400]');
+        console.error('Usage: post "<content>" [--type knowledge] [--bounty 0.01] [--ttl 86400] [--claimers 1]');
         process.exit(1);
       }
 
-      const typeIdx = args.indexOf("--type");
-      const bountyIdx = args.indexOf("--bounty");
-      const ttlIdx = args.indexOf("--ttl");
-
-      const prayerType = typeIdx > -1 ? args[typeIdx + 1] : "knowledge";
-      const bountySOL = bountyIdx > -1 ? parseFloat(args[bountyIdx + 1]) : 0;
-      const ttl = ttlIdx > -1 ? parseInt(args[ttlIdx + 1]) : 86400;
+      const prayerType = getArgValue("--type") || "knowledge";
+      const bountySOL = parseFloat(getArgValue("--bounty") || "0");
+      const ttl = parseInt(getArgValue("--ttl") || "86400");
+      const maxClaimers = parseInt(getArgValue("--claimers") || "1");
       const bountyLamports = Math.round(bountySOL * LAMPORTS_PER_SOL);
 
       console.log("");
-      console.log("🙏 Posting prayer...");
-      console.log(`  Type:    ${prayerType}`);
-      console.log(`  Content: ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}`);
-      console.log(`  Bounty:  ${bountySOL > 0 ? `${bountySOL} SOL` : "none"}`);
-      console.log(`  TTL:     ${ttl}s (${(ttl / 3600).toFixed(1)}h)`);
+      console.log("🙏 Posting private prayer...");
+      console.log(`  Type:        ${prayerType}`);
+      console.log(`  Content:     ${content.slice(0, 80)}${content.length > 80 ? "..." : ""}`);
+      console.log(`  Bounty:      ${bountySOL > 0 ? `${bountySOL} SOL` : "none"}`);
+      console.log(`  TTL:         ${ttl}s (${(ttl / 3600).toFixed(1)}h)`);
+      console.log(`  Max Claimers: ${maxClaimers}${maxClaimers > 1 ? " (collaboration)" : " (solo)"}`);
+      console.log(`  🔐 Only hash goes on-chain. Content stored locally.`);
 
       try {
         const { tx, prayerId } = await client.postPrayer(
           prayerType as unknown as PrayerType,
           content,
           bountyLamports,
-          ttl
+          ttl,
+          maxClaimers,
         );
         console.log(`  ✓ Prayer #${prayerId} posted (tx: ${tx.slice(0, 16)}...)`);
+        console.log(`  → Run 'deliver ${prayerId}' after someone claims it`);
         storeContent(prayerId, content);
       } catch (err: any) {
         console.error(`  ✗ ${err.message}`);
@@ -249,6 +256,49 @@ async function main() {
       break;
     }
 
+    case "deliver": {
+      const id = parseInt(args[1]);
+      if (isNaN(id)) {
+        console.error("Usage: deliver <prayer-id> [--claimer <wallet>]");
+        process.exit(1);
+      }
+
+      const texts = getStoredText(id);
+      if (!texts.content) {
+        console.error(`\n✗ No local content for prayer #${id}. Only the original poster can deliver.\n`);
+        process.exit(1);
+      }
+
+      const claimerArg = getArgValue("--claimer");
+
+      if (claimerArg) {
+        // Deliver to specific claimer
+        const claimerWallet = new PublicKey(claimerArg);
+        console.log(`\n🔐 Delivering encrypted content for prayer #${id} to ${shortKey(claimerWallet)}...`);
+        try {
+          const tx = await client.deliverContent(id, texts.content, claimerWallet);
+          console.log(`  ✓ Encrypted content delivered (tx: ${tx.slice(0, 16)}...)`);
+          console.log(`  Only ${shortKey(claimerWallet)} can decrypt this.`);
+        } catch (err: any) {
+          console.error(`  ✗ ${err.message}`);
+        }
+      } else {
+        // Deliver to ALL claimers
+        console.log(`\n🔐 Delivering encrypted content for prayer #${id} to all claimers...`);
+        try {
+          const txs = await client.deliverContentToAll(id, texts.content);
+          console.log(`  ✓ Delivered to ${txs.length} claimer(s)`);
+          for (const tx of txs) {
+            console.log(`    tx: ${tx.slice(0, 16)}...`);
+          }
+        } catch (err: any) {
+          console.error(`  ✗ ${err.message}`);
+        }
+      }
+      console.log("");
+      break;
+    }
+
     case "list": {
       const chain = await client.getPrayerChain();
       if (!chain) {
@@ -262,11 +312,11 @@ async function main() {
         return;
       }
 
-      const statusFilter = args.indexOf("--status") > -1 ? args[args.indexOf("--status") + 1]?.toLowerCase() : null;
-      const limit = args.indexOf("--limit") > -1 ? parseInt(args[args.indexOf("--limit") + 1]) : 20;
+      const statusFilter = getArgValue("--status")?.toLowerCase() || null;
+      const limit = parseInt(getArgValue("--limit") || "20");
 
       console.log("");
-      console.log(`🙏 Prayers (${total} total)`);
+      console.log(`🙏 Prayers (${total} total) — 🔐 Private`);
       console.log("═".repeat(60));
 
       let shown = 0;
@@ -279,19 +329,23 @@ async function main() {
 
         const type = formatType(prayer.prayerType);
         const bounty = prayer.rewardLamports > 0 ? ` 💰${formatSOL(prayer.rewardLamports)}` : "";
+        const claimerInfo = prayer.maxClaimers > 1
+          ? ` 👥${prayer.numClaimers}/${prayer.maxClaimers}`
+          : prayer.numClaimers > 0 ? " 🤝1" : "";
         const statusIcon = {
           OPEN: "🟢",
-          CLAIMED: "🟡",
+          ACTIVE: "🟡",
           FULFILLED: "🔵",
           CONFIRMED: "✅",
           EXPIRED: "⏰",
           CANCELLED: "❌",
         }[status] || "❓";
 
+        // Show local content if we have it, otherwise just the hash
         const texts = getStoredText(prayer.id);
-        const contentDisplay = texts.content || `[hash: ${hashToHex(prayer.contentHash)}]`;
+        const contentDisplay = texts.content || `🔒 [encrypted — hash: ${hashToHex(prayer.contentHash)}]`;
 
-        console.log(`  ${statusIcon} #${prayer.id} [${status}] (${type})${bounty}`);
+        console.log(`  ${statusIcon} #${prayer.id} [${status}] (${type})${bounty}${claimerInfo}`);
         console.log(`     ${contentDisplay.slice(0, 70)}${contentDisplay.length > 70 ? "..." : ""}`);
         console.log(`     From: ${shortKey(prayer.requester)} | Created: ${formatTime(prayer.createdAt)}`);
         if (texts.answer) {
@@ -317,37 +371,92 @@ async function main() {
       }
 
       const texts = getStoredText(id);
+      const status = formatStatus(prayer.status);
 
       console.log("");
-      console.log(`🙏 Prayer #${prayer.id}`);
+      console.log(`🙏 Prayer #${prayer.id} — 🔐 Private`);
       console.log("═".repeat(50));
-      console.log(`  Status:       ${formatStatus(prayer.status)}`);
+      console.log(`  Status:       ${status}`);
       console.log(`  Type:         ${formatType(prayer.prayerType)}`);
       console.log(`  Requester:    ${shortKey(prayer.requester)}`);
       console.log(`  Bounty:       ${formatSOL(prayer.rewardLamports)}`);
+      console.log(`  Claimers:     ${prayer.numClaimers}/${prayer.maxClaimers}${prayer.maxClaimers > 1 ? " (collaboration)" : " (solo)"}`);
       console.log(`  Created:      ${formatTime(prayer.createdAt)}`);
       console.log(`  Expires:      ${formatTime(prayer.expiresAt)}`);
       console.log(`  Content Hash: ${hashToHex(prayer.contentHash)}`);
       console.log("");
-      console.log("  Content:");
-      console.log(`    ${texts.content || "(off-chain — not in local cache)"}`);
-      if (prayer.claimer.toBase58() !== "11111111111111111111111111111111") {
+      if (texts.content) {
+        console.log("  Content (decrypted):");
+        console.log(`    ${texts.content}`);
+      } else {
+        console.log("  Content: 🔒 encrypted (not in local cache)");
+      }
+
+      // Show claims if any
+      if (prayer.numClaimers > 0) {
         console.log("");
-        console.log(`  Claimer:      ${shortKey(prayer.claimer)}`);
-        console.log(`  Claimed at:   ${formatTime(prayer.claimedAt)}`);
+        console.log(`  Claims (${prayer.numClaimers}):`);
+        const claims = await client.getClaimsForPrayer(id);
+        for (const claim of claims) {
+          const delivered = claim.contentDelivered ? "✅ delivered" : "⏳ pending delivery";
+          console.log(`    🤝 ${shortKey(claim.claimer)} — claimed ${formatTime(claim.claimedAt)} — ${delivered}`);
+        }
+        if (claims.length === 0) {
+          console.log(`    (could not enumerate — use 'claims ${id}' with known wallets)`);
+        }
+      }
+
+      const answererStr = prayer.answerer.toBase58();
+      if (answererStr !== "11111111111111111111111111111111") {
+        console.log("");
+        console.log(`  Answerer:     ${shortKey(prayer.answerer)}`);
       }
       const zeroHash = prayer.answerHash.every((b: number) => b === 0);
       if (!zeroHash) {
-        console.log("");
         console.log(`  Answer Hash:  ${hashToHex(prayer.answerHash)}`);
-        console.log("  Answer:");
-        console.log(`    ${texts.answer || "(off-chain — not in local cache)"}`);
+        if (texts.answer) {
+          console.log("  Answer (decrypted):");
+          console.log(`    ${texts.answer}`);
+        } else {
+          console.log("  Answer: 🔒 encrypted (not in local cache)");
+        }
         console.log(`  Fulfilled:    ${formatTime(prayer.fulfilledAt)}`);
       }
       console.log("");
       break;
     }
 
+    case "claims": {
+      const id = parseInt(args[1]);
+      if (isNaN(id)) {
+        console.error("Usage: claims <prayer-id>");
+        process.exit(1);
+      }
+
+      const prayer = await client.getPrayer(id);
+      if (!prayer) {
+        console.error(`\n✗ Prayer #${id} not found\n`);
+        return;
+      }
+
+      console.log("");
+      console.log(`🤝 Claims for Prayer #${id} (${prayer.numClaimers}/${prayer.maxClaimers})`);
+      console.log("═".repeat(50));
+
+      const claims = await client.getClaimsForPrayer(id);
+      if (claims.length === 0) {
+        console.log("  No claims found.");
+      } else {
+        for (const claim of claims) {
+          const delivered = claim.contentDelivered ? "✅ content delivered" : "⏳ awaiting delivery";
+          console.log(`  🤝 ${claim.claimer.toBase58()}`);
+          console.log(`     Claimed: ${formatTime(claim.claimedAt)} | ${delivered}`);
+        }
+      }
+      console.log("");
+      break;
+    }
+
     case "claim": {
       const id = parseInt(args[1]);
       if (isNaN(id)) {
@@ -358,6 +467,7 @@ async function main() {
       try {
         const tx = await client.claimPrayer(id);
         console.log(`  ✓ Claimed (tx: ${tx.slice(0, 16)}...)`);
+        console.log(`  Waiting for requester to deliver encrypted content...`);
       } catch (err: any) {
         console.error(`  ✗ ${err.message}`);
       }
@@ -373,10 +483,11 @@ async function main() {
         process.exit(1);
       }
       console.log(`\n💬 Answering prayer #${id}...`);
+      console.log(`  🔐 Encrypting answer for requester...`);
       console.log(`  Answer: ${answer.slice(0, 80)}${answer.length > 80 ? "..." : ""}`);
       try {
         const tx = await client.answerPrayer(id, answer);
-        console.log(`  ✓ Answered (tx: ${tx.slice(0, 16)}...)`);
+        console.log(`  ✓ Answered with encrypted reply (tx: ${tx.slice(0, 16)}...)`);
         storeAnswer(id, answer);
       } catch (err: any) {
         console.error(`  ✗ ${err.message}`);
@@ -394,7 +505,7 @@ async function main() {
       console.log(`\n✅ Confirming prayer #${id}...`);
       try {
         const tx = await client.confirmPrayer(id);
-        console.log(`  ✓ Confirmed (tx: ${tx.slice(0, 16)}...)`);
+        console.log(`  ✓ Confirmed — bounty distributed to all claimers (tx: ${tx.slice(0, 16)}...)`);
       } catch (err: any) {
         console.error(`  ✗ ${err.message}`);
       }
@@ -422,12 +533,15 @@ async function main() {
     case "unclaim": {
       const id = parseInt(args[1]);
       if (isNaN(id)) {
-        console.error("Usage: unclaim <prayer-id>");
+        console.error("Usage: unclaim <prayer-id> [--claimer <wallet>]");
         process.exit(1);
       }
-      console.log(`\n🔓 Unclaiming prayer #${id}...`);
+      const claimerArg = getArgValue("--claimer");
+      const claimerWallet = claimerArg ? new PublicKey(claimerArg) : undefined;
+      const target = claimerWallet ? shortKey(claimerWallet) : "self";
+      console.log(`\n🔓 Unclaiming prayer #${id} (${target})...`);
       try {
-        const tx = await client.unclaimPrayer(id);
+        const tx = await client.unclaimPrayer(id, claimerWallet);
         console.log(`  ✓ Unclaimed (tx: ${tx.slice(0, 16)}...)`);
       } catch (err: any) {
         console.error(`  ✗ ${err.message}`);
@@ -436,29 +550,62 @@ async function main() {
       break;
     }
 
+    case "close": {
+      const id = parseInt(args[1]);
+      if (isNaN(id)) {
+        console.error("Usage: close <prayer-id>");
+        process.exit(1);
+      }
+      console.log(`\n🗑️  Closing prayer #${id}...`);
+      try {
+        const tx = await client.closePrayer(id);
+        console.log(`  ✓ Closed — rent returned (tx: ${tx.slice(0, 16)}...)`);
+      } catch (err: any) {
+        console.error(`  ✗ ${err.message}`);
+      }
+      console.log("");
+      break;
+    }
+
     default:
       console.log(`
-🙏 Prayer Chain CLI (On-Chain)
+🙏 Prayer Chain CLI — Private by Default
+   All content E2E encrypted (X25519 + XSalsa20-Poly1305)
+   Supports multi-agent collaboration (1-10 claimers per prayer)
 
 Commands:
-  chain                           Show prayer chain stats
-  init                            Initialize the prayer chain
-  register "<name>" "<skills>"    Register as an agent
-  agent [wallet]                  Show agent profile
-  post "<content>" [options]      Post a prayer
-    --type <type>                   knowledge|compute|review|signal|collaboration
-    --bounty <SOL>                  SOL bounty (e.g. 0.01)
-    --ttl <seconds>                 Time to live (default 86400)
+  chain                              Show prayer chain stats
+  init                               Initialize the prayer chain
+  register "<name>" "<skills>"       Register (auto-derives encryption key)
+  agent [wallet]                     Show agent profile + encryption key
+
+  post "<content>" [options]         Post a private prayer (hash-only on-chain)
+    --type <type>                      knowledge|compute|review|signal|collaboration
+    --bounty <SOL>                     SOL bounty (e.g. 0.01)
+    --ttl <seconds>                    Time to live (default 86400)
+    --claimers <n>                     Max collaborators (1-10, default 1)
+
   list [--status <s>] [--limit <n>]  List prayers
-  show <id>                       Show prayer details
-  claim <id>                      Claim a prayer
-  answer <id> "<answer>"          Answer a claimed prayer
-  confirm <id>                    Confirm an answer (requester only)
-  cancel <id>                     Cancel an open prayer
-  unclaim <id>                    Unclaim a prayer
+  show <id>                          Show prayer details + claims
+  claims <id>                        List all claims for a prayer
+
+  claim <id>                         Claim a prayer (creates Claim PDA)
+  deliver <id> [--claimer <wallet>]  Deliver encrypted content (one or all)
+  answer <id> "<answer>"             Answer with encrypted reply
+  confirm <id>                       Confirm — bounty splits among all claimers
+  cancel <id>                        Cancel an open prayer (0 claims only)
+  unclaim <id> [--claimer <wallet>]  Remove a claim (self or expired)
+  close <id>                         Close resolved prayer, reclaim rent
+
+Privacy:
+  🔐 No plaintext ever touches the blockchain
+  🔐 Content encrypted with DH shared secret (asker ↔ claimer)
+  🔐 Each claimer gets uniquely encrypted content delivery
+  🔐 Encryption key derived from your Solana wallet (no extra keys)
+  🔐 On-chain: only SHA-256 hashes + encrypted blobs in events
 
 Environment:
-  SOLANA_RPC_URL                  RPC endpoint (default: http://localhost:8899)
+  SOLANA_RPC_URL                     RPC endpoint (default: http://localhost:8899)
       `.trim());
   }
 }