2020117-agent 0.3.6 → 0.3.7

package/dist/agent.d.ts

@@ -2,7 +2,7 @@
 /**
  * Unified Agent Runtime — runs as a long-lived daemon that handles:
  *   1. Async platform tasks (inbox polling → accept → process → submit result)
- *   2. P2P sessions (Hyperswarm + CLINK per-minute billing)
+ *   2. P2P sessions (Hyperswarm + Lightning invoice per-minute billing)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *

package/dist/agent.js

@@ -2,7 +2,7 @@
 /**
  * Unified Agent Runtime — runs as a long-lived daemon that handles:
  *   1. Async platform tasks (inbox polling → accept → process → submit result)
- *   2. P2P sessions (Hyperswarm + CLINK per-minute billing)
+ *   2. P2P sessions (Hyperswarm + Lightning invoice per-minute billing)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *
@@ -69,10 +69,11 @@ import { randomBytes } from 'crypto';
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { createProcessor } from './processor.js';
 import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, getProfile, reportSession, } from './api.js';
-import { initClinkAgent, collectPayment, generateInvoice } from './clink.js';
+import { generateInvoice } from './clink.js';
+import { receiveCashuToken } from './cashu.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
-// Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
+// Polyfill global WebSocket for Node.js < 22 (needed by ws tunnel)
 if (!globalThis.WebSocket)
     globalThis.WebSocket = WebSocket;
 // --- Config from env ---
@@ -81,7 +82,7 @@ const MAX_CONCURRENT = Number(process.env.MAX_JOBS) || 3;
 const POLL_INTERVAL = Number(process.env.POLL_INTERVAL) || 30_000;
 const SATS_PER_CHUNK = Number(process.env.SATS_PER_CHUNK) || 1;
 const CHUNKS_PER_PAYMENT = Number(process.env.CHUNKS_PER_PAYMENT) || 10;
-// --- CLINK payment config ---
+// --- Lightning payment config ---
 let LIGHTNING_ADDRESS = process.env.LIGHTNING_ADDRESS || '';
 // --- Sub-task delegation config ---
 const SUB_KIND = process.env.SUB_KIND ? Number(process.env.SUB_KIND) : null;
@@ -161,12 +162,7 @@ async function main() {
             console.log(`[${label}] Lightning Address loaded from platform: ${LIGHTNING_ADDRESS}`);
         }
     }
-    // 3. Initialize CLINK agent identity (for P2P session debit)
-    if (LIGHTNING_ADDRESS) {
-        const { pubkey } = initClinkAgent();
-        console.log(`[${label}] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
-    }
-    // 4. Platform registration + heartbeat
+    // 3. Platform registration + heartbeat
     await setupPlatform(label);
     // 5. Async inbox poller
     startInboxPoller(label);
@@ -319,6 +315,37 @@ async function delegateAPI(kind, input, bidSats, provider) {
     throw new Error(`Sub-task ${jobId} timed out after 120s`);
 }
 const activeSessions = new Map();
+/** Send a billing tick to the customer — Cashu: request amount, Invoice: send bolt11 */
+async function sendBillingTick(node, session, amount, label) {
+    const tickId = randomBytes(4).toString('hex');
+    if (session.paymentMethod === 'invoice') {
+        try {
+            const bolt11 = await generateInvoice(LIGHTNING_ADDRESS, amount);
+            node.send(session.socket, {
+                type: 'session_tick',
+                id: tickId,
+                session_id: session.sessionId,
+                bolt11,
+                amount,
+            });
+            console.log(`[${label}] Session ${session.sessionId}: sent invoice (${amount} sats)`);
+        }
+        catch (e) {
+            console.log(`[${label}] Session ${session.sessionId}: invoice error (${e.message}) — ending session`);
+            endSession(node, session, label);
+        }
+    }
+    else {
+        // Cashu: just request the amount, customer sends token
+        node.send(session.socket, {
+            type: 'session_tick',
+            id: tickId,
+            session_id: session.sessionId,
+            amount,
+        });
+        console.log(`[${label}] Session ${session.sessionId}: requested payment (${amount} sats)`);
+    }
+}
 // Backend WebSocket connections for WS tunnel (keyed by ws_id)
 const backendWebSockets = new Map();
 async function startSwarmListener(label) {
@@ -336,174 +363,75 @@ async function startSwarmListener(label) {
         }
         // --- Session protocol ---
         if (msg.type === 'session_start') {
-            if (!LIGHTNING_ADDRESS) {
-                console.warn(`[${label}] Session rejected: no --lightning-address configured`);
-                node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
-                return;
-            }
-            // Negotiate payment method: customer requests "invoice" or "ndebit" (default)
-            const paymentMethod = msg.payment_method || (msg.ndebit ? 'ndebit' : 'invoice');
-            if (paymentMethod === 'ndebit' && !msg.ndebit) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'ndebit payment requires ndebit authorization' });
+            // Negotiate payment method: cashu (default) or invoice (requires Lightning Address)
+            const paymentMethod = msg.payment_method || 'cashu';
+            if (paymentMethod === 'invoice' && !LIGHTNING_ADDRESS) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'Invoice payment requires provider Lightning Address' });
                 return;
             }
             const satsPerMinute = state.skill?.pricing?.sats_per_minute
                 || Number(process.env.SATS_PER_MINUTE)
                 || msg.sats_per_minute
                 || 10;
-            const BILLING_INTERVAL_MIN = 10;
-            const debitAmount = satsPerMinute * BILLING_INTERVAL_MIN;
+            const BILLING_INTERVAL_MIN = 1;
+            const billingAmount = satsPerMinute * BILLING_INTERVAL_MIN;
             const sessionId = randomBytes(8).toString('hex');
-            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, payment=${paymentMethod}, billing every ${BILLING_INTERVAL_MIN}min (${debitAmount} sats)`);
+            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, payment=${paymentMethod}, billing every ${BILLING_INTERVAL_MIN}min (${billingAmount} sats)`);
             const session = {
                 socket,
                 peerId,
                 sessionId,
                 satsPerMinute,
                 paymentMethod,
-                ndebit: msg.ndebit || '',
                 totalEarned: 0,
                 startedAt: Date.now(),
-                lastDebitAt: Date.now(),
-                debitTimer: null,
+                lastPaidAt: Date.now(),
+                billingTimer: null,
                 timeoutTimer: null,
             };
             activeSessions.set(sessionId, session);
-            if (paymentMethod === 'ndebit') {
-                // --- CLINK pull mode: provider debits customer immediately ---
-                let firstDebit;
+            node.send(socket, {
+                type: 'session_ack',
+                id: msg.id,
+                session_id: sessionId,
+                sats_per_minute: satsPerMinute,
+                payment_method: paymentMethod,
+            });
+            // Send first billing tick
+            await sendBillingTick(node, session, billingAmount, label);
+            // Recurring billing every 10 minutes
+            session.billingTimer = setInterval(() => {
+                sendBillingTick(node, session, billingAmount, label);
+            }, BILLING_INTERVAL_MIN * 60_000);
+            return;
+        }
+        // Customer sent payment (Cashu token or Lightning preimage)
+        if (msg.type === 'session_tick_ack') {
+            const session = activeSessions.get(msg.session_id || '');
+            if (!session)
+                return;
+            if (msg.cashu_token) {
+                // Cashu mode: verify token by swapping at mint
                 try {
-                    firstDebit = await collectPayment({
-                        ndebit: session.ndebit,
-                        lightningAddress: LIGHTNING_ADDRESS,
-                        amountSats: debitAmount,
-                    });
+                    const { amount } = await receiveCashuToken(msg.cashu_token);
+                    session.totalEarned += amount;
+                    session.lastPaidAt = Date.now();
+                    console.log(`[${label}] Session ${session.sessionId}: Cashu payment received (+${amount}, total: ${session.totalEarned} sats)`);
                 }
                 catch (e) {
-                    console.warn(`[${label}] Session ${sessionId}: first debit error: ${e.message}`);
-                    node.send(socket, { type: 'error', id: msg.id, message: `Payment error: ${e.message}` });
-                    activeSessions.delete(sessionId);
-                    return;
-                }
-                if (!firstDebit.ok) {
-                    console.warn(`[${label}] Session ${sessionId}: first debit failed: ${firstDebit.error}`);
-                    node.send(socket, { type: 'error', id: msg.id, message: `Payment failed: ${firstDebit.error}` });
-                    activeSessions.delete(sessionId);
-                    return;
+                    console.warn(`[${label}] Session ${session.sessionId}: Cashu token invalid: ${e.message} — ending session`);
+                    endSession(node, session, label);
                 }
-                session.totalEarned += debitAmount;
-                session.lastDebitAt = Date.now();
-                console.log(`[${label}] Session ${sessionId}: first ${BILLING_INTERVAL_MIN}min paid (${debitAmount} sats)`);
-                node.send(socket, {
-                    type: 'session_ack',
-                    id: msg.id,
-                    session_id: sessionId,
-                    sats_per_minute: satsPerMinute,
-                    payment_method: 'ndebit',
-                });
-                node.send(socket, {
-                    type: 'session_tick_ack',
-                    id: sessionId,
-                    session_id: sessionId,
-                    amount: debitAmount,
-                    balance: msg.budget ? msg.budget - session.totalEarned : undefined,
-                });
-                // Recurring debit every 10 minutes
-                session.debitTimer = setInterval(async () => {
-                    let debit;
-                    try {
-                        debit = await collectPayment({
-                            ndebit: session.ndebit,
-                            lightningAddress: LIGHTNING_ADDRESS,
-                            amountSats: debitAmount,
-                        });
-                    }
-                    catch (e) {
-                        console.log(`[${label}] Session ${sessionId}: debit error (${e.message}) — ending session`);
-                        endSession(node, session, label);
-                        return;
-                    }
-                    if (!debit.ok) {
-                        console.log(`[${label}] Session ${sessionId}: debit failed (${debit.error}) — ending session`);
-                        endSession(node, session, label);
-                        return;
-                    }
-                    session.totalEarned += debitAmount;
-                    session.lastDebitAt = Date.now();
-                    console.log(`[${label}] Session ${sessionId}: debit OK (+${debitAmount}, total: ${session.totalEarned} sats)`);
-                    node.send(socket, {
-                        type: 'session_tick_ack',
-                        id: sessionId,
-                        session_id: sessionId,
-                        amount: debitAmount,
-                        balance: msg.budget ? msg.budget - session.totalEarned : undefined,
-                    });
-                }, BILLING_INTERVAL_MIN * 60_000);
             }
-            else {
-                // --- Invoice push mode: provider sends bolt11, customer pays ---
-                node.send(socket, {
-                    type: 'session_ack',
-                    id: msg.id,
-                    session_id: sessionId,
-                    sats_per_minute: satsPerMinute,
-                    payment_method: 'invoice',
-                });
-                // Generate and send first invoice
-                let firstInvoice;
-                try {
-                    firstInvoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
-                }
-                catch (e) {
-                    console.warn(`[${label}] Session ${sessionId}: invoice error: ${e.message}`);
-                    node.send(socket, { type: 'error', id: msg.id, message: `Invoice error: ${e.message}` });
-                    activeSessions.delete(sessionId);
-                    return;
-                }
-                const tickId = randomBytes(4).toString('hex');
-                node.send(socket, {
-                    type: 'session_tick',
-                    id: tickId,
-                    session_id: sessionId,
-                    bolt11: firstInvoice,
-                    amount: debitAmount,
-                });
-                console.log(`[${label}] Session ${sessionId}: sent first invoice (${debitAmount} sats)`);
-                // Recurring invoices every 10 minutes
-                session.debitTimer = setInterval(async () => {
-                    let invoice;
-                    try {
-                        invoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
-                    }
-                    catch (e) {
-                        console.log(`[${label}] Session ${sessionId}: invoice error (${e.message}) — ending session`);
-                        endSession(node, session, label);
-                        return;
-                    }
-                    const tid = randomBytes(4).toString('hex');
-                    node.send(socket, {
-                        type: 'session_tick',
-                        id: tid,
-                        session_id: sessionId,
-                        bolt11: invoice,
-                        amount: debitAmount,
-                    });
-                    console.log(`[${label}] Session ${sessionId}: sent invoice for ${debitAmount} sats`);
-                }, BILLING_INTERVAL_MIN * 60_000);
+            else if (msg.preimage) {
+                // Invoice mode: preimage proves payment
+                const amount = msg.amount || 0;
+                session.totalEarned += amount;
+                session.lastPaidAt = Date.now();
+                console.log(`[${label}] Session ${session.sessionId}: invoice payment received (+${amount}, total: ${session.totalEarned} sats)`);
             }
             return;
         }
-        // Handle invoice payment confirmation (invoice mode only)
-        if (msg.type === 'session_tick_ack' && msg.preimage) {
-            const session = activeSessions.get(msg.session_id || '');
-            if (!session || session.paymentMethod !== 'invoice')
-                return;
-            const amount = msg.amount || 0;
-            session.totalEarned += amount;
-            session.lastDebitAt = Date.now();
-            console.log(`[${label}] Session ${session.sessionId}: payment received (+${amount}, total: ${session.totalEarned} sats)`);
-            return;
-        }
         if (msg.type === 'session_end') {
             const session = activeSessions.get(msg.session_id || '');
             if (!session)
@@ -688,7 +616,7 @@ async function startSwarmListener(label) {
             return;
         }
     });
-    // Handle customer disconnect — payments already settled via CLINK
+    // Handle customer disconnect
     node.on('peer-leave', (peerId) => {
         const tag = peerId.slice(0, 8);
         // Find and end all sessions for this peer
@@ -720,10 +648,10 @@ function findSessionBySocket(socket) {
 }
 function endSession(node, session, label) {
     const durationS = Math.round((Date.now() - session.startedAt) / 1000);
-    // Stop debit timer
-    if (session.debitTimer) {
-        clearInterval(session.debitTimer);
-        session.debitTimer = null;
+    // Stop billing timer
+    if (session.billingTimer) {
+        clearInterval(session.billingTimer);
+        session.billingTimer = null;
     }
     if (session.timeoutTimer) {
         clearTimeout(session.timeoutTimer);
@@ -752,7 +680,7 @@ function endSession(node, session, label) {
         // Socket may already be closed (peer disconnect)
     }
     console.log(`[${label}] Session ${session.sessionId} ended: ${session.totalEarned} sats, ${durationS}s`);
-    // Update P2P lifetime counters — no batch claim needed with CLINK (payments settled instantly)
+    // Update P2P lifetime counters
     state.p2pSessionsCompleted++;
     state.p2pTotalEarnedSats += session.totalEarned;
     // Report session to platform activity feed (best-effort, no content exposed)

package/dist/api.d.ts

@@ -7,8 +7,6 @@
  */
 /** Returns the resolved agent name from env or first key in file */
 export declare function loadAgentName(): string | null;
-/** Returns the ndebit from env or .2020117_keys file */
-export declare function loadNdebit(): string | null;
 export declare function hasApiKey(): boolean;
 /** Fetch the authenticated agent's profile from the platform. */
 export declare function getProfile(): Promise<{
@@ -99,16 +97,6 @@ export declare function walletPayInvoice(bolt11: string): Promise<{
     error?: string;
 }>;
 export declare function walletGetBalance(): Promise<number>;
-export interface ProxyDebitResult {
-    ok: boolean;
-    preimage?: string;
-    error?: string;
-}
-export declare function proxyDebit(opts: {
-    ndebit: string;
-    lightningAddress: string;
-    amountSats: number;
-}): Promise<ProxyDebitResult | null>;
 /**
  * Report a completed P2P session to the platform for the activity feed.
  * Content stays private — only metadata (kind, duration, sats) is sent.

package/dist/api.js

@@ -51,29 +51,6 @@ export function loadAgentName() {
     }
     return null;
 }
-/** Returns the ndebit from env or .2020117_keys file */
-export function loadNdebit() {
-    if (process.env.CLINK_NDEBIT)
-        return process.env.CLINK_NDEBIT;
-    const agentName = process.env.AGENT_NAME || process.env.AGENT;
-    for (const dir of [process.cwd(), homedir()]) {
-        try {
-            const raw = readFileSync(join(dir, '.2020117_keys'), 'utf-8');
-            const keys = JSON.parse(raw);
-            if (agentName && keys[agentName]?.ndebit)
-                return keys[agentName].ndebit;
-            if (!agentName) {
-                const first = Object.values(keys)[0];
-                if (first?.ndebit)
-                    return first.ndebit;
-            }
-        }
-        catch {
-            // try next
-        }
-    }
-    return null;
-}
 const API_KEY = loadApiKey();
 // --- Helpers ---
 async function apiGet(path, auth = true) {
@@ -303,7 +280,7 @@ export async function walletPayInvoice(bolt11) {
     if (!API_KEY)
         return { ok: false, error: 'No API key' };
     try {
-        const resp = await fetch(`${BASE_URL}/api/wallet/send`, {
+        const resp = await fetch(`${BASE_URL}/api/wallet/pay`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${API_KEY}` },
             body: JSON.stringify({ bolt11 }),
@@ -321,13 +298,6 @@ export async function walletGetBalance() {
     const data = await apiGet('/api/wallet/balance');
     return data?.balance_sats ?? 0;
 }
-export async function proxyDebit(opts) {
-    return apiPost('/api/dvm/proxy-debit', {
-        ndebit: opts.ndebit,
-        lightning_address: opts.lightningAddress,
-        amount_sats: opts.amountSats,
-    });
-}
 /**
  * Report a completed P2P session to the platform for the activity feed.
  * Content stays private — only metadata (kind, duration, sats) is sent.

package/dist/cashu.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Cashu eCash utilities — send and receive tokens over P2P
+ *
+ * Customer: pre-loads tokens, splits per billing tick, sends to Provider
+ * Provider: receives tokens, swaps at mint to verify, accumulates proofs
+ */
+export type Proof = {
+    id: string;
+    amount: number;
+    secret: string;
+    C: string;
+};
+/**
+ * Split proofs to create a Cashu token of the exact amount.
+ * Returns the encoded token string and remaining change proofs.
+ */
+export declare function sendCashuToken(mintUrl: string, proofs: Proof[], amount: number): Promise<{
+    token: string;
+    change: Proof[];
+}>;
+/**
+ * Verify and claim a Cashu token — swaps proofs with the mint to prevent double-spend.
+ * Returns the claimed proofs (now owned by the receiver).
+ */
+export declare function receiveCashuToken(tokenStr: string): Promise<{
+    proofs: Proof[];
+    amount: number;
+    mintUrl: string;
+}>;
+/**
+ * Inspect a token's amount and mint without claiming it.
+ */
+export declare function peekCashuToken(tokenStr: string): {
+    amount: number;
+    mint: string;
+};
+/**
+ * Decode a token string to get the raw proofs and mint URL.
+ */
+export declare function decodeCashuToken(tokenStr: string): {
+    mint: string;
+    proofs: Proof[];
+};
+/**
+ * Encode proofs back into a portable token string.
+ */
+export declare function encodeCashuToken(mintUrl: string, proofs: Proof[]): string;
+/**
+ * Request a mint quote — returns a Lightning invoice to pay for minting tokens.
+ */
+export declare function createMintQuote(mintUrl: string, amountSats: number): Promise<{
+    quote: string;
+    invoice: string;
+}>;
+/**
+ * Claim a paid mint quote — polls for payment, then mints proofs and returns an encoded token.
+ * Throws if the quote is not paid within the timeout.
+ */
+export declare function claimMintQuote(mintUrl: string, amountSats: number, quoteId: string, timeoutMs?: number): Promise<string>;

package/dist/cashu.js

@@ -0,0 +1,91 @@
+/**
+ * Cashu eCash utilities — send and receive tokens over P2P
+ *
+ * Customer: pre-loads tokens, splits per billing tick, sends to Provider
+ * Provider: receives tokens, swaps at mint to verify, accumulates proofs
+ */
+import { CashuMint, CashuWallet, getEncodedTokenV4, getDecodedToken } from '@cashu/cashu-ts';
+// Cache wallet instances per mint URL
+const walletCache = new Map();
+async function getWallet(mintUrl) {
+    let wallet = walletCache.get(mintUrl);
+    if (!wallet) {
+        const mint = new CashuMint(mintUrl);
+        wallet = new CashuWallet(mint);
+        await wallet.loadMint();
+        walletCache.set(mintUrl, wallet);
+    }
+    return wallet;
+}
+/**
+ * Split proofs to create a Cashu token of the exact amount.
+ * Returns the encoded token string and remaining change proofs.
+ */
+export async function sendCashuToken(mintUrl, proofs, amount) {
+    const wallet = await getWallet(mintUrl);
+    const { send, keep } = await wallet.send(amount, proofs);
+    const token = getEncodedTokenV4({ mint: mintUrl, proofs: send });
+    return { token, change: keep };
+}
+/**
+ * Verify and claim a Cashu token — swaps proofs with the mint to prevent double-spend.
+ * Returns the claimed proofs (now owned by the receiver).
+ */
+export async function receiveCashuToken(tokenStr) {
+    const decoded = getDecodedToken(tokenStr);
+    const mintUrl = decoded.mint;
+    const wallet = await getWallet(mintUrl);
+    const proofs = await wallet.receive(tokenStr);
+    const amount = proofs.reduce((sum, p) => sum + p.amount, 0);
+    return { proofs, amount, mintUrl };
+}
+/**
+ * Inspect a token's amount and mint without claiming it.
+ */
+export function peekCashuToken(tokenStr) {
+    const decoded = getDecodedToken(tokenStr);
+    const amount = decoded.proofs.reduce((sum, p) => sum + p.amount, 0);
+    return { amount, mint: decoded.mint };
+}
+/**
+ * Decode a token string to get the raw proofs and mint URL.
+ */
+export function decodeCashuToken(tokenStr) {
+    const decoded = getDecodedToken(tokenStr);
+    return { mint: decoded.mint, proofs: decoded.proofs };
+}
+/**
+ * Encode proofs back into a portable token string.
+ */
+export function encodeCashuToken(mintUrl, proofs) {
+    return getEncodedTokenV4({ mint: mintUrl, proofs });
+}
+/**
+ * Request a mint quote — returns a Lightning invoice to pay for minting tokens.
+ */
+export async function createMintQuote(mintUrl, amountSats) {
+    const wallet = await getWallet(mintUrl);
+    const quoteRes = await wallet.createMintQuote(amountSats);
+    return { quote: quoteRes.quote, invoice: quoteRes.request };
+}
+/**
+ * Claim a paid mint quote — polls for payment, then mints proofs and returns an encoded token.
+ * Throws if the quote is not paid within the timeout.
+ */
+export async function claimMintQuote(mintUrl, amountSats, quoteId, timeoutMs = 60_000) {
+    const wallet = await getWallet(mintUrl);
+    // Poll until paid or timeout
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const check = await wallet.checkMintQuote(quoteId);
+        if (check.state === 'PAID') {
+            const proofs = await wallet.mintProofs(amountSats, quoteId);
+            return getEncodedTokenV4({ mint: mintUrl, proofs });
+        }
+        if (check.state === 'ISSUED') {
+            throw new Error('Mint quote already issued');
+        }
+        await new Promise(r => setTimeout(r, 2000));
+    }
+    throw new Error('Mint quote payment timeout');
+}

package/dist/clink.d.ts

@@ -1,27 +1,9 @@
 /**
- * CLINK payment utilities — debit-based Lightning payments for P2P sessions
+ * Lightning payment utilities — invoice generation via LNURL-pay
  *
- * Provider uses ndebit to pull payments from customer's wallet.
- * Invoice generation via LNURL-pay from provider's own Lightning Address.
+ * Provider generates invoices from their own Lightning Address.
+ * Customer pays invoices via built-in wallet (POST /api/wallet/send).
  */
-export declare function initClinkAgent(): {
-    privateKey: Uint8Array;
-    pubkey: string;
-};
-export interface DebitResult {
-    ok: boolean;
-    preimage?: string;
-    error?: string;
-}
-/**
- * Provider calls this to debit customer's wallet via CLINK protocol.
- * Sends a Kind 21002 event to the customer's wallet service via Nostr relay.
- */
-export declare function debitCustomer(opts: {
-    ndebit: string;
-    bolt11: string;
-    timeoutSeconds?: number;
-}): Promise<DebitResult>;
 /**
  * Resolve a Lightning Address to a bolt11 invoice via LNURL-pay protocol.
  * The provider calls this on their OWN Lightning Address to generate
@@ -30,18 +12,3 @@ export declare function debitCustomer(opts: {
  * Flow: address → .well-known/lnurlp → callback?amount= → bolt11
  */
 export declare function generateInvoice(lightningAddress: string, amountSats: number): Promise<string>;
-/**
- * Full payment cycle: generate invoice from provider's Lightning Address,
- * then debit customer's wallet via CLINK.
- *
- * Priority: platform proxy (if API key available) → direct debit (if agent key initialized).
- * Proxy uses the platform's pre-authorized CLINK identity, so providers don't need
- * individual DebitAccess on customer wallets. Direct debit works for power users
- * who pre-authorize each other's keys.
- */
-export declare function collectPayment(opts: {
-    ndebit: string;
-    lightningAddress: string;
-    amountSats: number;
-    timeoutSeconds?: number;
-}): Promise<DebitResult>;

package/dist/clink.js

@@ -1,43 +1,9 @@
 /**
- * CLINK payment utilities — debit-based Lightning payments for P2P sessions
+ * Lightning payment utilities — invoice generation via LNURL-pay
  *
- * Provider uses ndebit to pull payments from customer's wallet.
- * Invoice generation via LNURL-pay from provider's own Lightning Address.
+ * Provider generates invoices from their own Lightning Address.
+ * Customer pays invoices via built-in wallet (POST /api/wallet/send).
  */
-import { ClinkSDK, decodeBech32, generateSecretKey, getPublicKey, newNdebitPaymentRequest } from '@shocknet/clink-sdk';
-import { hasApiKey, proxyDebit } from './api.js';
-// --- Agent identity ---
-let agentKey = null;
-let agentPubkey = null;
-export function initClinkAgent() {
-    agentKey = generateSecretKey();
-    agentPubkey = getPublicKey(agentKey);
-    console.log(`[clink] Agent identity: ${agentPubkey.slice(0, 16)}...`);
-    return { privateKey: agentKey, pubkey: agentPubkey };
-}
-/**
- * Provider calls this to debit customer's wallet via CLINK protocol.
- * Sends a Kind 21002 event to the customer's wallet service via Nostr relay.
- */
-export async function debitCustomer(opts) {
-    if (!agentKey)
-        throw new Error('CLINK agent not initialized — call initClinkAgent() first');
-    const decoded = decodeBech32(opts.ndebit);
-    if (decoded.type !== 'ndebit')
-        throw new Error(`Invalid ndebit string (got type: ${decoded.type})`);
-    const sdk = new ClinkSDK({
-        privateKey: agentKey,
-        relays: [decoded.data.relay],
-        toPubKey: decoded.data.pubkey,
-        defaultTimeoutSeconds: opts.timeoutSeconds ?? 30,
-    });
-    const result = await sdk.Ndebit(newNdebitPaymentRequest(opts.bolt11, undefined, decoded.data.pointer));
-    if (result.res === 'ok') {
-        return { ok: true, preimage: result.preimage };
-    }
-    return { ok: false, error: result.error || 'Debit rejected' };
-}
-// --- Invoice generation via LNURL-pay ---
 /**
  * Resolve a Lightning Address to a bolt11 invoice via LNURL-pay protocol.
  * The provider calls this on their OWN Lightning Address to generate
@@ -73,35 +39,3 @@ export async function generateInvoice(lightningAddress, amountSats) {
         throw new Error(`No invoice returned: ${invoiceData.reason || 'unknown error'}`);
     return invoiceData.pr;
 }
-// --- Combined: generate invoice + debit ---
-/**
- * Full payment cycle: generate invoice from provider's Lightning Address,
- * then debit customer's wallet via CLINK.
- *
- * Priority: platform proxy (if API key available) → direct debit (if agent key initialized).
- * Proxy uses the platform's pre-authorized CLINK identity, so providers don't need
- * individual DebitAccess on customer wallets. Direct debit works for power users
- * who pre-authorize each other's keys.
- */
-export async function collectPayment(opts) {
-    // Try platform proxy first (provider doesn't need DebitAccess)
-    if (hasApiKey()) {
-        console.log(`[clink] Proxy debit: ${opts.amountSats} sats → ${opts.lightningAddress}`);
-        const result = await proxyDebit({
-            ndebit: opts.ndebit,
-            lightningAddress: opts.lightningAddress,
-            amountSats: opts.amountSats,
-        });
-        if (result) {
-            return { ok: result.ok, preimage: result.preimage, error: result.error };
-        }
-        console.warn('[clink] Proxy debit unavailable, trying direct...');
-    }
-    // Fallback: direct debit (requires provider's CLINK key to be authorized)
-    const bolt11 = await generateInvoice(opts.lightningAddress, opts.amountSats);
-    return debitCustomer({
-        ndebit: opts.ndebit,
-        bolt11,
-        timeoutSeconds: opts.timeoutSeconds,
-    });
-}

package/dist/p2p-customer.d.ts

@@ -1,58 +1,11 @@
 /**
- * Shared P2P customer protocol — connects to a provider via Hyperswarm,
- * negotiates price, authorizes CLINK debit payments, and streams chunks.
- *
- * The customer sends an ndebit authorization with the request. The provider
- * pulls payments directly from the customer's wallet via CLINK debit —
- * the customer does not send payment messages.
+ * Shared P2P customer protocol — utility functions for connecting
+ * to providers via Hyperswarm.
  *
  * Exports:
- *   - P2PStreamOptions — config interface
- *   - streamFromProvider() — async generator that yields chunks from a provider
  *   - queryProviderSkill() — queries a provider's skill manifest via an existing connection
  */
 import { SwarmNode } from './swarm.js';
-/**
- * Configuration for a P2P connection.
- */
-export interface P2PStreamOptions {
-    /** DVM kind number (e.g. 5100 for text generation) */
-    kind: number;
-    /** The input/prompt to send to the provider */
-    input: string;
-    /** Total budget in sats for this session */
-    budgetSats: number;
-    /** Customer's ndebit1... authorization for CLINK debit payments */
-    ndebit: string;
-    /** Maximum acceptable price per chunk in sats (default: 5) */
-    maxSatsPerChunk?: number;
-    /** Overall timeout in milliseconds (default: 120_000) */
-    timeoutMs?: number;
-    /** Log prefix label (default: 'p2p') */
-    label?: string;
-    /** Additional job parameters passed in the request message */
-    params?: Record<string, unknown>;
-}
-/**
- * Connect to a provider via Hyperswarm, authorize CLINK debit payments,
- * and yield output chunks as they arrive.
- *
- * Creates and destroys its own temporary SwarmNode — callers do not need
- * to manage any swarm state.
- *
- * @example
- * ```ts
- * for await (const chunk of streamFromProvider({
- *   kind: 5100,
- *   input: 'Explain quantum computing',
- *   budgetSats: 50,
- *   ndebit: 'ndebit1...',
- * })) {
- *   process.stdout.write(chunk)
- * }
- * ```
- */
-export declare function streamFromProvider(opts: P2PStreamOptions): AsyncGenerator<string>;
 /**
  * Query a provider's skill manifest over an existing P2P connection.
  *

package/dist/p2p-customer.js

@@ -1,165 +1,11 @@
 /**
- * Shared P2P customer protocol — connects to a provider via Hyperswarm,
- * negotiates price, authorizes CLINK debit payments, and streams chunks.
- *
- * The customer sends an ndebit authorization with the request. The provider
- * pulls payments directly from the customer's wallet via CLINK debit —
- * the customer does not send payment messages.
+ * Shared P2P customer protocol — utility functions for connecting
+ * to providers via Hyperswarm.
  *
  * Exports:
- *   - P2PStreamOptions — config interface
- *   - streamFromProvider() — async generator that yields chunks from a provider
  *   - queryProviderSkill() — queries a provider's skill manifest via an existing connection
  */
-import { SwarmNode, topicFromKind } from './swarm.js';
 import { randomBytes } from 'crypto';
-/**
- * Connect to a provider via Hyperswarm, authorize CLINK debit payments,
- * and yield output chunks as they arrive.
- *
- * Creates and destroys its own temporary SwarmNode — callers do not need
- * to manage any swarm state.
- *
- * @example
- * ```ts
- * for await (const chunk of streamFromProvider({
- *   kind: 5100,
- *   input: 'Explain quantum computing',
- *   budgetSats: 50,
- *   ndebit: 'ndebit1...',
- * })) {
- *   process.stdout.write(chunk)
- * }
- * ```
- */
-export async function* streamFromProvider(opts) {
-    const { kind, input, budgetSats, ndebit, maxSatsPerChunk = 5, timeoutMs = 120_000, label = 'p2p', params, } = opts;
-    if (!ndebit) {
-        throw new Error('ndebit authorization required for P2P connection');
-    }
-    const jobId = randomBytes(8).toString('hex');
-    const tag = `${label}-${jobId.slice(0, 8)}`;
-    const node = new SwarmNode();
-    const topic = topicFromKind(kind);
-    try {
-        console.log(`[${tag}] Looking for kind ${kind} provider...`);
-        await node.connect(topic);
-        const peer = await node.waitForPeer(30_000);
-        console.log(`[${tag}] Connected to provider: ${peer.peerId.slice(0, 12)}...`);
-        // Query provider's skill manifest for pricing before committing
-        const skill = await queryProviderSkill(node, peer.socket, kind);
-        if (skill) {
-            const pricing = skill.pricing;
-            const jobPrice = pricing?.sats_per_job ?? pricing?.[String(kind)];
-            if (jobPrice !== undefined) {
-                console.log(`[${tag}] Provider pricing: ${jobPrice} sats/job`);
-                if (typeof jobPrice === 'number' && jobPrice > budgetSats) {
-                    throw new Error(`Provider price ${jobPrice} sats exceeds budget ${budgetSats} sats`);
-                }
-            }
-            if (skill.name)
-                console.log(`[${tag}] Provider: ${skill.name}`);
-        }
-        // Channel: message handler pushes chunks, generator consumes them
-        const chunks = [];
-        let finished = false;
-        let error = null;
-        let notify = null;
-        function wake() {
-            if (notify) {
-                notify();
-                notify = null;
-            }
-        }
-        function waitForChunk() {
-            if (chunks.length > 0 || finished || error)
-                return Promise.resolve();
-            return new Promise(r => { notify = r; });
-        }
-        // Timeout
-        const timeout = setTimeout(() => {
-            error = new Error(`P2P delegation timed out after ${timeoutMs / 1000}s`);
-            wake();
-        }, timeoutMs);
-        node.on('message', async (msg) => {
-            if (msg.id !== jobId)
-                return;
-            switch (msg.type) {
-                case 'offer': {
-                    const spc = msg.sats_per_chunk ?? 0;
-                    if (spc > maxSatsPerChunk) {
-                        node.send(peer.socket, { type: 'stop', id: jobId });
-                        error = new Error(`Price too high: ${spc} sat/chunk > max ${maxSatsPerChunk}`);
-                        wake();
-                        return;
-                    }
-                    console.log(`[${tag}] Offer: ${spc} sat/chunk, ${msg.chunks_per_payment ?? 0} chunks/payment`);
-                    // No action needed — provider will debit our wallet via CLINK
-                    break;
-                }
-                case 'payment_ack':
-                    // Provider debited our wallet and is reporting the amount
-                    console.log(`[${tag}] Provider debited: ${msg.amount} sats`);
-                    break;
-                case 'accepted':
-                    console.log(`[${tag}] Accepted, streaming...`);
-                    break;
-                case 'chunk':
-                    if (msg.data) {
-                        chunks.push(msg.data);
-                        wake();
-                    }
-                    break;
-                case 'pay_required':
-                    // With CLINK, provider handles payment collection directly
-                    // This shouldn't normally fire, but log it if it does
-                    console.log(`[${tag}] Provider requested payment (will be debited via CLINK)`);
-                    break;
-                case 'result':
-                    console.log(`[${tag}] Result: ${(msg.output || '').length} chars, ${msg.total_sats ?? '?'} sats`);
-                    finished = true;
-                    wake();
-                    break;
-                case 'error':
-                    error = new Error(`Provider error: ${msg.message}`);
-                    wake();
-                    break;
-            }
-        });
-        // Send request with ndebit authorization (provider will use it to debit)
-        const requestMsg = {
-            type: 'request',
-            id: jobId,
-            kind,
-            input,
-            budget: budgetSats,
-            ndebit,
-        };
-        if (params) {
-            requestMsg.params = params;
-        }
-        node.send(peer.socket, requestMsg);
-        // Yield chunks as they arrive
-        while (true) {
-            await waitForChunk();
-            if (error) {
-                clearTimeout(timeout);
-                throw error;
-            }
-            // Drain all available chunks
-            while (chunks.length > 0) {
-                yield chunks.shift();
-            }
-            if (finished) {
-                clearTimeout(timeout);
-                return;
-            }
-        }
-    }
-    finally {
-        await node.destroy();
-    }
-}
 /**
  * Query a provider's skill manifest over an existing P2P connection.
  *

package/dist/session.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute payments (CLINK ndebit or Lightning invoice).
+ * per-minute Lightning invoice payments.
  *
  * Features:
- *   - Payment negotiation: ndebit (provider pulls) or invoice (customer pushes)
+ *   - Customer pays provider's invoices via built-in wallet
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *

package/dist/session.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute payments (CLINK ndebit or Lightning invoice).
+ * per-minute Lightning invoice payments.
  *
  * Features:
- *   - Payment negotiation: ndebit (provider pulls) or invoice (customer pushes)
+ *   - Customer pays provider's invoices via built-in wallet
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *
@@ -37,27 +37,31 @@ for (const arg of process.argv.slice(2)) {
         case '--provider':
             process.env.PROVIDER_PEER = val;
             break;
-        case '--ndebit':
-            process.env.CLINK_NDEBIT = val;
+        case '--cashu-token':
+            process.env.CASHU_TOKEN = val;
+            break;
+        case '--mint':
+            process.env.CASHU_MINT_URL = val;
             break;
     }
 }
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
-import { loadNdebit, walletPayInvoice, walletGetBalance, hasApiKey } from './api.js';
+import { walletPayInvoice, walletGetBalance, hasApiKey } from './api.js';
+import { decodeCashuToken, sendCashuToken, createMintQuote, claimMintQuote } from './cashu.js';
 import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
 import { mkdirSync, writeFileSync } from 'fs';
 import { WebSocketServer, WebSocket as WsWebSocket } from 'ws';
-// Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
-if (!globalThis.WebSocket)
-    globalThis.WebSocket = WsWebSocket;
 // --- Config ---
 const KIND = Number(process.env.DVM_KIND) || 5200;
 const BUDGET = Number(process.env.BUDGET_SATS) || 500;
 const PORT = Number(process.env.SESSION_PORT) || 8080;
-const NDEBIT = process.env.CLINK_NDEBIT || loadNdebit() || '';
+const CASHU_TOKEN = process.env.CASHU_TOKEN || '';
+const MINT_URL = process.env.CASHU_MINT_URL || 'https://8333.space:3338';
+// Mutable Cashu wallet state (loaded from CASHU_TOKEN at startup)
+let cashuState = null;
 const TICK_INTERVAL_MS = 60_000;
 const HTTP_TIMEOUT_MS = 60_000;
 const state = {
@@ -163,14 +167,14 @@ function setupMessageHandler() {
                 break;
             }
             case 'session_tick': {
-                // Invoice mode: provider sent a bolt11 invoice — pay it
-                if (msg.bolt11 && msg.amount !== undefined) {
-                    const amount = msg.amount;
-                    if (state.totalSpent + amount > BUDGET) {
-                        log(`Budget exhausted (need ${amount}, remaining ${remainingSats()}) — ending session`);
-                        endSession();
-                        break;
-                    }
+                const amount = msg.amount || 0;
+                if (state.totalSpent + amount > BUDGET) {
+                    log(`Budget exhausted (need ${amount}, remaining ${remainingSats()}) — ending session`);
+                    endSession();
+                    break;
+                }
+                if (msg.bolt11) {
+                    // Invoice mode: pay bolt11 via wallet
                     log(`Paying invoice: ${amount} sats...`);
                     const payResult = await walletPayInvoice(msg.bolt11);
                     if (payResult.ok) {
@@ -185,20 +189,39 @@ function setupMessageHandler() {
                         });
                     }
                     else {
-                        warn(`Payment failed: ${payResult.error} — ending session`);
+                        warn(`Invoice payment failed: ${payResult.error} — ending session`);
+                        endSession();
+                    }
+                }
+                else if (cashuState) {
+                    // Cashu mode: split tokens and send
+                    log(`Paying with Cashu: ${amount} sats...`);
+                    try {
+                        const { token, change } = await sendCashuToken(cashuState.mintUrl, cashuState.proofs, amount);
+                        cashuState.proofs = change;
+                        state.totalSpent += amount;
+                        log(`Paid ${amount} sats (total: ${state.totalSpent}, ~${estimatedMinutesLeft()} min left)`);
+                        state.node.send(state.socket, {
+                            type: 'session_tick_ack',
+                            id: msg.id,
+                            session_id: state.sessionId,
+                            cashu_token: token,
+                            amount,
+                        });
+                    }
+                    catch (e) {
+                        warn(`Cashu payment failed: ${e.message} — ending session`);
                         endSession();
                     }
                 }
+                else {
+                    warn('No payment method available — ending session');
+                    endSession();
+                }
                 break;
             }
             case 'session_tick_ack': {
-                // Ndebit mode: provider debited our wallet and is reporting the result
-                if (msg.amount !== undefined) {
-                    state.totalSpent += msg.amount;
-                }
-                if (msg.balance !== undefined) {
-                    log(`Debit: ${msg.amount ?? '?'} sats (balance: ${msg.balance} sats, ${estimatedMinutesLeft()} min left)`);
-                }
+                // Ignore — this is our own ack echoed back
                 break;
             }
             case 'error': {
@@ -256,10 +279,9 @@ function setupMessageHandler() {
         }
     });
 }
-// --- 3. Payment tracking (CLINK — provider pulls, customer monitors) ---
-// With CLINK debit, the provider generates invoices and debits the customer's
-// wallet directly. The customer receives session_tick_ack notifications with
-// updated balance. No tick timer needed on the customer side.
+// --- 3. Payment tracking ---
+// Provider sends session_tick with bolt11 invoice every billing period.
+// Customer pays via built-in wallet and sends session_tick_ack with preimage.
 // --- 4. HTTP proxy ---
 function startHttpProxy() {
     return new Promise((resolve, reject) => {
@@ -667,25 +689,59 @@ async function main() {
     state.satsPerMinute = satsPerMinute;
     log(`Pricing: ${satsPerMinute} sats/min`);
     log(`Budget: ${BUDGET} sats (~${Math.floor(BUDGET / satsPerMinute)} min)`);
-    // 4. Negotiate payment method: ndebit (CLINK pull) or invoice (wallet push)
+    // 4. Determine payment method: Cashu (default) or invoice (fallback)
     let paymentMethod;
-    if (NDEBIT) {
-        paymentMethod = 'ndebit';
-        log(`Payment: CLINK ndebit (provider pulls per-minute)`);
+    if (CASHU_TOKEN) {
+        // Load pre-existing Cashu token
+        const { mint, proofs } = decodeCashuToken(CASHU_TOKEN);
+        const tokenAmount = proofs.reduce((sum, p) => sum + p.amount, 0);
+        cashuState = { mintUrl: mint, proofs };
+        paymentMethod = 'cashu';
+        log(`Payment: Cashu (${tokenAmount} sats from ${mint})`);
+        if (tokenAmount < BUDGET) {
+            warn(`Cashu token (${tokenAmount} sats) is less than budget (${BUDGET} sats)`);
+        }
     }
     else if (hasApiKey()) {
-        paymentMethod = 'invoice';
+        // Auto-mint Cashu tokens via NWC wallet
         const balance = await walletGetBalance();
-        if (balance < BUDGET) {
-            warn(`Wallet balance (${balance} sats) is less than budget (${BUDGET} sats).`);
-            warn(`Fund your wallet: POST ${process.env.API_2020117_URL || 'https://2020117.xyz'}/api/wallet/invoice`);
+        if (balance <= 0) {
+            warn('Wallet balance is 0. Cannot auto-mint Cashu tokens.');
+            await node.destroy();
+            process.exit(1);
+        }
+        const mintAmount = Math.min(balance, BUDGET);
+        log(`Wallet balance: ${balance} sats — minting ${mintAmount} sats from ${MINT_URL}`);
+        try {
+            // 1. Request mint quote (Lightning invoice)
+            const { quote, invoice } = await createMintQuote(MINT_URL, mintAmount);
+            log(`Mint quote: ${quote} (invoice: ${invoice.slice(0, 30)}...)`);
+            // 2. Pay the invoice via platform NWC wallet
+            log('Paying mint invoice via NWC wallet...');
+            const payResult = await walletPayInvoice(invoice);
+            if (!payResult.ok) {
+                throw new Error(`Payment failed: ${payResult.error}`);
+            }
+            log(`Invoice paid (preimage: ${payResult.preimage?.slice(0, 16)}...)`);
+            // 3. Claim minted proofs
+            log('Claiming minted tokens...');
+            const token = await claimMintQuote(MINT_URL, mintAmount, quote);
+            const { mint, proofs } = decodeCashuToken(token);
+            cashuState = { mintUrl: mint, proofs };
+            paymentMethod = 'cashu';
+            const totalMinted = proofs.reduce((s, p) => s + p.amount, 0);
+            log(`Minted ${totalMinted} sats Cashu token — using Cashu payment mode`);
+        }
+        catch (e) {
+            warn(`Auto-mint failed: ${e.message}`);
+            await node.destroy();
+            process.exit(1);
         }
-        log(`Payment: invoice (wallet pays provider, balance: ${balance} sats)`);
     }
     else {
         warn('No payment method available.');
-        warn('  Option 1: --ndebit=ndebit1... (CLINK wallet authorization)');
-        warn('  Option 2: --agent=NAME (built-in wallet via API key)');
+        warn('  Option 1 (default): --cashu-token=cashuA... (Cashu eCash token)');
+        warn('  Option 2: --agent=NAME (auto-mints Cashu via NWC wallet)');
         await node.destroy();
         process.exit(1);
     }
@@ -697,7 +753,6 @@ async function main() {
         budget: BUDGET,
         sats_per_minute: satsPerMinute,
         payment_method: paymentMethod,
-        ...(paymentMethod === 'ndebit' ? { ndebit: NDEBIT } : {}),
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);

package/dist/swarm.d.ts

@@ -45,10 +45,10 @@ export interface SwarmMessage {
     sats_per_minute?: number;
     balance?: number;
     duration_s?: number;
-    ndebit?: string;
-    payment_method?: 'ndebit' | 'invoice';
+    payment_method?: 'cashu' | 'invoice';
     bolt11?: string;
     preimage?: string;
+    cashu_token?: string;
     method?: string;
     path?: string;
     headers?: Record<string, string>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "2020117-agent",
-  "version": "0.3.6",
-  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
+  "version": "0.3.7",
+  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + Cashu/Lightning payments",
   "type": "module",
   "bin": {
     "2020117-agent": "./dist/agent.js",
@@ -13,7 +13,8 @@
   "exports": {
     "./processor": "./dist/processor.js",
     "./swarm": "./dist/swarm.js",
-    "./clink": "./dist/clink.js",
+    "./cashu": "./dist/cashu.js",
+    "./lightning": "./dist/clink.js",
     "./api": "./dist/api.js"
   },
   "scripts": {
@@ -26,7 +27,7 @@
     "dev:session": "npx tsx src/session.ts"
   },
   "dependencies": {
-    "@shocknet/clink-sdk": "^1.5.4",
+    "@cashu/cashu-ts": "^2.5.3",
     "hyperswarm": "^4.17.0",
     "ws": "^8.19.0"
   },