voidforge-build 23.9.1

package/dist/wizard/lib/treasury-backup.js

@@ -0,0 +1,127 @@
+/**
+ * Treasury Backup — Encrypted daily snapshots (§9.17, §9.19.13).
+ *
+ * Daily snapshot of ~/.voidforge/treasury/ + growth state.
+ * Encrypted with vault password (AES-256-GCM).
+ * Retain 30 days. Runs as a heartbeat daemon scheduled job.
+ *
+ * PRD Reference: §9.17 (Backup Strategy), §9.19.13 (scope extension)
+ */
+import { readdir, readFile, mkdir, unlink } from 'node:fs/promises';
+import { createCipheriv, randomBytes, scrypt } from 'node:crypto';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { TREASURY_DIR } from './financial-core.js';
+// Backup stays global (backs up all project treasury data)
+const BACKUP_DIR = join(homedir(), '.voidforge', 'backups');
+const RETENTION_DAYS = 30;
+/**
+ * Create an encrypted daily backup of the treasury directory.
+ * The backup is a gzipped tar-like concatenation of files, encrypted with AES-256-GCM.
+ * The vault password is the encryption key (via scrypt).
+ */
+export async function createDailyBackup(vaultPassword) {
+    const date = new Date().toISOString().split('T')[0]; // YYYY-MM-DD
+    const backupPath = join(BACKUP_DIR, `treasury-${date}.backup.enc`);
+    await mkdir(BACKUP_DIR, { recursive: true });
+    // Skip if today's backup already exists
+    if (existsSync(backupPath)) {
+        return { path: backupPath, files: 0 };
+    }
+    // Collect all files from treasury directory
+    const files = [];
+    if (existsSync(TREASURY_DIR)) {
+        await collectFiles(TREASURY_DIR, TREASURY_DIR, files);
+    }
+    if (files.length === 0) {
+        return { path: '', files: 0 };
+    }
+    // Serialize file manifest
+    const manifest = files.map(f => ({
+        path: f.relativePath,
+        size: f.content.length,
+    }));
+    // Create a simple archive format: manifest JSON + file contents
+    const archiveData = Buffer.concat([
+        Buffer.from(JSON.stringify(manifest) + '\n---MANIFEST_END---\n'),
+        ...files.map(f => Buffer.concat([
+            Buffer.from(`---FILE:${f.relativePath}:${f.content.length}---\n`),
+            f.content,
+            Buffer.from('\n'),
+        ])),
+    ]);
+    // Encrypt the archive (§9.19.13: encrypted with vault password)
+    const salt = randomBytes(32);
+    const iv = randomBytes(16);
+    const key = await deriveKey(vaultPassword, salt);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const encrypted = Buffer.concat([cipher.update(archiveData), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    // Format: salt (32) + iv (16) + authTag (16) + ciphertext
+    const output = Buffer.concat([salt, iv, authTag, encrypted]);
+    // Write atomically
+    const tmpPath = backupPath + '.tmp';
+    const { writeFile: writeFileAsync, rename: renameAsync } = await import('node:fs/promises');
+    await writeFileAsync(tmpPath, output, { mode: 0o600 });
+    await renameAsync(tmpPath, backupPath);
+    // Prune old backups
+    await pruneOldBackups();
+    return { path: backupPath, files: files.length };
+}
+async function collectFiles(dir, baseDir, result) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await collectFiles(fullPath, baseDir, result);
+        }
+        else if (entry.isFile()) {
+            // v17.0: Size limit to prevent unbounded memory allocation
+            const fileStat = await import('node:fs/promises').then(m => m.stat(fullPath));
+            if (fileStat.size > 100 * 1024 * 1024) {
+                console.warn(`Treasury backup: skipping ${entry.name} (${fileStat.size} bytes > 100MB limit)`);
+                continue;
+            }
+            const relativePath = fullPath.replace(baseDir + '/', '');
+            const content = await readFile(fullPath);
+            result.push({ relativePath, content });
+        }
+    }
+}
+async function deriveKey(password, salt) {
+    return new Promise((resolve, reject) => {
+        scrypt(password.slice(0, 256), salt, 32, { N: 131072, r: 8, p: 1 }, (err, key) => {
+            if (err)
+                reject(err);
+            else
+                resolve(key);
+        });
+    });
+}
+async function pruneOldBackups() {
+    if (!existsSync(BACKUP_DIR))
+        return;
+    const entries = await readdir(BACKUP_DIR);
+    const cutoff = Date.now() - RETENTION_DAYS * 24 * 60 * 60 * 1000;
+    for (const entry of entries) {
+        if (!entry.startsWith('treasury-') || !entry.endsWith('.backup.enc'))
+            continue;
+        const dateStr = entry.replace('treasury-', '').replace('.backup.enc', '');
+        const fileDate = new Date(dateStr).getTime();
+        if (fileDate < cutoff) {
+            await unlink(join(BACKUP_DIR, entry));
+        }
+    }
+}
+/**
+ * Export all financial data (encrypted with vault password).
+ * Used by /treasury --export and uninstall safety.
+ */
+export async function exportTreasuryData(vaultPassword, outputPath) {
+    const result = await createDailyBackup(vaultPassword);
+    if (result.path) {
+        const { copyFile } = await import('node:fs/promises');
+        await copyFile(result.path, outputPath);
+    }
+}

package/dist/wizard/lib/treasury-circuit-breakers.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Treasury Circuit Breakers — evaluation logic for funding freeze conditions.
+ *
+ * Implements PRD S13.2 circuit breakers:
+ *   CB-1: Provider unavailable for 3 consecutive polls
+ *   CB-2: Off-ramp pending beyond SLA window (24 hours)
+ *   CB-3: Reconciliation mismatch for 2 consecutive closes
+ *   CB-4: Google invoice due soon + insufficient fiat
+ *   CB-5: Meta debit fails or payment-risk state
+ *   CB-6: Max daily treasury movement exceeded ($50,000 default)
+ */
+import type { TreasuryHeartbeatState, PendingTransfer } from './treasury-io.js';
+export interface CircuitBreakerResult {
+    shouldFreeze: boolean;
+    reasons: string[];
+}
+export declare function evaluateCircuitBreakers(state: TreasuryHeartbeatState): CircuitBreakerResult;
+/** Evaluate CB-2 specifically for pending transfers beyond SLA. */
+export declare function evaluateTransferSlaBreaker(transfers: PendingTransfer[], slaHours?: number): CircuitBreakerResult;
+/** Evaluate CB-4 and CB-5 from billing adapter state. */
+export declare function evaluateBillingBreakers(opts: {
+    googleInvoiceDueSoon: boolean;
+    googleInvoiceCents: number;
+    bankBalanceCents: number;
+    minimumBufferCents: number;
+    metaDebitFailed: boolean;
+    metaPaymentRisk: boolean;
+}): CircuitBreakerResult;

package/dist/wizard/lib/treasury-circuit-breakers.js

@@ -0,0 +1,74 @@
+/**
+ * Treasury Circuit Breakers — evaluation logic for funding freeze conditions.
+ *
+ * Implements PRD S13.2 circuit breakers:
+ *   CB-1: Provider unavailable for 3 consecutive polls
+ *   CB-2: Off-ramp pending beyond SLA window (24 hours)
+ *   CB-3: Reconciliation mismatch for 2 consecutive closes
+ *   CB-4: Google invoice due soon + insufficient fiat
+ *   CB-5: Meta debit fails or payment-risk state
+ *   CB-6: Max daily treasury movement exceeded ($50,000 default)
+ */
+export function evaluateCircuitBreakers(state) {
+    const reasons = [];
+    // CB-1: Provider unavailable for 3 consecutive polls
+    if (state.consecutiveProviderFailures >= 3) {
+        reasons.push(`Stablecoin provider unavailable for ${state.consecutiveProviderFailures} consecutive polls — freeze funding`);
+    }
+    // CB-2: Off-ramp pending beyond SLA window (24 hours)
+    // Checked via pending transfers — caller handles this with transfer data
+    // CB-3: Reconciliation mismatch for 2 consecutive closes
+    if (state.consecutiveMismatches >= 2) {
+        reasons.push(`Reconciliation mismatch for ${state.consecutiveMismatches} consecutive closes — freeze funding`);
+    }
+    // CB-6: Max daily treasury movement exceeded ($50,000 default)
+    const MAX_DAILY_MOVEMENT_CENTS = 5_000_000; // $50,000
+    if (state.dailyMovementCents > MAX_DAILY_MOVEMENT_CENTS) {
+        reasons.push(`Daily treasury movement $${(state.dailyMovementCents / 100).toFixed(2)} exceeds max $${(MAX_DAILY_MOVEMENT_CENTS / 100).toFixed(2)} — freeze funding`);
+    }
+    return {
+        shouldFreeze: reasons.length > 0,
+        reasons,
+    };
+}
+/** Evaluate CB-2 specifically for pending transfers beyond SLA. */
+export function evaluateTransferSlaBreaker(transfers, slaHours = 24) {
+    const reasons = [];
+    const slaMs = slaHours * 60 * 60 * 1000;
+    const now = Date.now();
+    for (const t of transfers) {
+        if (t.status !== 'pending' && t.status !== 'processing')
+            continue;
+        const age = now - new Date(t.initiatedAt).getTime();
+        if (age > slaMs) {
+            reasons.push(`Transfer ${t.id} pending for ${Math.round(age / (60 * 60 * 1000))}h — exceeds ${slaHours}h SLA — freeze funding`);
+        }
+    }
+    return {
+        shouldFreeze: reasons.length > 0,
+        reasons,
+    };
+}
+/** Evaluate CB-4 and CB-5 from billing adapter state. */
+export function evaluateBillingBreakers(opts) {
+    const reasons = [];
+    // CB-4: Google invoice due soon + insufficient fiat
+    if (opts.googleInvoiceDueSoon) {
+        const availableForInvoice = opts.bankBalanceCents - opts.minimumBufferCents;
+        if (availableForInvoice < opts.googleInvoiceCents) {
+            reasons.push(`Google invoice $${(opts.googleInvoiceCents / 100).toFixed(2)} due soon but only ` +
+                `$${(availableForInvoice / 100).toFixed(2)} available — freeze non-essential funding`);
+        }
+    }
+    // CB-5: Meta debit fails or payment-risk state
+    if (opts.metaDebitFailed) {
+        reasons.push('Meta direct debit failed — freeze funding until bank balance confirmed');
+    }
+    if (opts.metaPaymentRisk) {
+        reasons.push('Meta account in payment-risk state — freeze funding');
+    }
+    return {
+        shouldFreeze: reasons.length > 0,
+        reasons,
+    };
+}

package/dist/wizard/lib/treasury-handlers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Treasury Socket Handlers — HTTP-style request handlers for the treasury API.
+ *
+ * Handles POST/GET routes over the daemon's Unix socket:
+ *   POST /treasury/offramp   — Initiate off-ramp (vault+TOTP required)
+ *   POST /treasury/freeze    — Manual freeze
+ *   POST /treasury/unfreeze  — Manual unfreeze (vault+TOTP required)
+ *   GET  /treasury/balances  — Balance snapshot
+ *   GET  /treasury/funding-status — Funding pipeline status
+ *   GET  /treasury/runway    — Runway forecast
+ *
+ * PRD Reference: S10.4, S16
+ */
+import type { Logger, FreezeFn } from './treasury-io.js';
+export declare function handleTreasuryRequest(method: string, path: string, _body: unknown, auth: {
+    vaultVerified: boolean;
+    totpVerified: boolean;
+}, logger: Logger, triggerFreeze: FreezeFn, vaultKey: string | null): Promise<{
+    status: number;
+    body: unknown;
+} | null>;

package/dist/wizard/lib/treasury-handlers.js

@@ -0,0 +1,281 @@
+/**
+ * Treasury Socket Handlers — HTTP-style request handlers for the treasury API.
+ *
+ * Handles POST/GET routes over the daemon's Unix socket:
+ *   POST /treasury/offramp   — Initiate off-ramp (vault+TOTP required)
+ *   POST /treasury/freeze    — Manual freeze
+ *   POST /treasury/unfreeze  — Manual unfreeze (vault+TOTP required)
+ *   GET  /treasury/balances  — Balance snapshot
+ *   GET  /treasury/funding-status — Funding pipeline status
+ *   GET  /treasury/runway    — Runway forecast
+ *
+ * PRD Reference: S10.4, S16
+ */
+import { appendFile, mkdir } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { TREASURY_DIR } from './financial-core.js';
+import { generateFundingPlan } from './financial/treasury-planner.js';
+import { evaluatePolicy, aggregateDecisions } from './financial/funding-policy.js';
+import { getTreasuryState, saveTreasuryState, isStablecoinConfigured, readPendingTransfers, writePendingTransfers, writeWalEntry, FUNDING_PLANS_LOG, TRANSFERS_LOG, } from './treasury-io.js';
+// ── Treasury Socket Handlers ─────────────────────────
+export async function handleTreasuryRequest(method, path, _body, auth, logger, triggerFreeze, vaultKey) {
+    const treasuryState = getTreasuryState();
+    // POST /treasury/offramp — vault+TOTP required
+    if (method === 'POST' && path === '/treasury/offramp') {
+        if (!auth.vaultVerified || !auth.totpVerified) {
+            return {
+                status: 403,
+                body: { ok: false, error: 'Off-ramp requires valid vault password + TOTP code' },
+            };
+        }
+        if (!isStablecoinConfigured()) {
+            return {
+                status: 400,
+                body: { ok: false, error: 'Stablecoin funding not configured' },
+            };
+        }
+        if (treasuryState.fundingFrozen) {
+            return {
+                status: 423,
+                body: { ok: false, error: `Funding frozen: ${treasuryState.freezeReason ?? 'unknown reason'}` },
+            };
+        }
+        logger.log('Off-ramp requested via treasury API');
+        // Write WAL entry first (ADR-3)
+        const intentId = randomUUID();
+        await writeWalEntry({
+            intentId,
+            operation: 'offramp',
+            params: _body,
+            status: 'pending',
+            createdAt: new Date().toISOString(),
+        });
+        try {
+            const { getStablecoinAdapter } = await import('./financial/adapter-factory.js');
+            const adapter = await getStablecoinAdapter(vaultKey, logger);
+            // Generate a funding plan using treasury planner
+            const bankBalance = treasuryState.bankBalanceCents;
+            const source = {
+                id: 'default-source',
+                provider: 'circle',
+                asset: 'USDC',
+                network: 'ETH',
+                sourceAccountId: 'default',
+                whitelistedDestinationBankId: 'default-bank',
+                status: 'active',
+            };
+            const bank = {
+                id: 'default-bank',
+                provider: 'mercury',
+                accountId: 'default',
+                currency: 'USD',
+                availableBalanceCents: bankBalance,
+                reservedBalanceCents: 0,
+                minimumBufferCents: 50_000, // $500
+            };
+            const config = {
+                minimumOfframpCents: 10_000, // $100
+                bufferTargetCents: 100_000, // $1,000
+                maxDailyOfframpCents: 5_000_000, // $50,000
+                targetRunwayDays: 30,
+            };
+            const obligations = [];
+            const plan = generateFundingPlan(source, bank, obligations, config, '');
+            if (!plan) {
+                return {
+                    status: 200,
+                    body: { ok: true, message: 'No funding needed — balance sufficient' },
+                };
+            }
+            // Evaluate policy before executing
+            const policyState = {
+                bankBalanceCents: bank.availableBalanceCents,
+                minimumBufferCents: bank.minimumBufferCents,
+                reservedCents: bank.reservedBalanceCents,
+                proposedOfframpCents: plan.requiredCents,
+                maxDailyMovementCents: config.maxDailyOfframpCents,
+                googleInvoiceDueSoon: false,
+                googleInvoiceCents: 0,
+                metaUsesDirectDebit: false,
+                metaForecast7DayCents: 0,
+                debitProtectionBufferCents: 0,
+                discrepancyExists: treasuryState.consecutiveMismatches > 0,
+                proposingBudgetRaise: false,
+                platformCapability: 'FULLY_FUNDABLE',
+                claimingAutonomousFunding: false,
+            };
+            const decisions = evaluatePolicy(policyState);
+            const aggregate = aggregateDecisions(decisions);
+            if (aggregate.action === 'freeze') {
+                await triggerFreeze(aggregate.blockingRules.map(r => r.reason).join('; '));
+                return {
+                    status: 423,
+                    body: { ok: false, error: 'Policy freeze triggered', rules: aggregate.blockingRules },
+                };
+            }
+            if (aggregate.action === 'deny') {
+                return {
+                    status: 403,
+                    body: {
+                        ok: false,
+                        error: 'Policy denied off-ramp',
+                        rules: aggregate.blockingRules,
+                    },
+                };
+            }
+            // Initiate the off-ramp
+            const planRef = {
+                id: plan.id,
+                sourceFundingId: plan.sourceFundingId,
+                destinationBankId: plan.destinationBankId,
+                requiredCents: plan.requiredCents,
+                idempotencyKey: plan.idempotencyKey,
+            };
+            const transfer = await adapter.initiateOfframp(planRef, plan.hash);
+            // Log the plan and transfer
+            await mkdir(TREASURY_DIR, { recursive: true });
+            await appendFile(FUNDING_PLANS_LOG, JSON.stringify(plan) + '\n', 'utf-8');
+            await appendFile(TRANSFERS_LOG, JSON.stringify(transfer) + '\n', 'utf-8');
+            // Track pending transfer
+            const pending = await readPendingTransfers();
+            pending.push({
+                id: transfer.id,
+                fundingPlanId: plan.id,
+                providerTransferId: transfer.providerTransferId,
+                amountCents: transfer.amountCents,
+                status: 'pending',
+                initiatedAt: transfer.initiatedAt,
+                lastPolledAt: transfer.initiatedAt,
+            });
+            await writePendingTransfers(pending);
+            // Update treasury state
+            treasuryState.pendingTransferCount += 1;
+            treasuryState.lastOfframpAt = new Date().toISOString();
+            // Track daily movement for CB-6
+            const today = new Date().toISOString().slice(0, 10);
+            if (treasuryState.dailyMovementDate !== today) {
+                treasuryState.dailyMovementCents = 0;
+                treasuryState.dailyMovementDate = today;
+            }
+            treasuryState.dailyMovementCents += plan.requiredCents;
+            // Complete WAL
+            await writeWalEntry({
+                intentId,
+                operation: 'offramp',
+                params: { planId: plan.id, transferId: transfer.id },
+                status: 'completed',
+                createdAt: new Date().toISOString(),
+                completedAt: new Date().toISOString(),
+            });
+            await saveTreasuryState();
+            logger.log(`Off-ramp initiated: $${(plan.requiredCents / 100).toFixed(2)} ` +
+                `via ${transfer.provider} (transfer ${transfer.id})`);
+            return {
+                status: 200,
+                body: {
+                    ok: true,
+                    message: 'Off-ramp initiated',
+                    plan: { id: plan.id, amountCents: plan.requiredCents, reason: plan.reason },
+                    transfer: { id: transfer.id, status: transfer.status, provider: transfer.provider },
+                },
+            };
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : 'Off-ramp failed';
+            logger.log(`Off-ramp error: ${msg}`);
+            await writeWalEntry({
+                intentId,
+                operation: 'offramp',
+                params: _body,
+                status: 'failed',
+                createdAt: new Date().toISOString(),
+                error: msg,
+            });
+            return { status: 500, body: { ok: false, error: `Off-ramp failed: ${msg}` } };
+        }
+    }
+    // POST /treasury/freeze — session token only (protective)
+    if (method === 'POST' && path === '/treasury/freeze') {
+        logger.log('Treasury FREEZE command received');
+        treasuryState.fundingFrozen = true;
+        treasuryState.freezeReason = 'Manual freeze via treasury API';
+        await saveTreasuryState();
+        return { status: 200, body: { ok: true, message: 'Funding frozen' } };
+    }
+    // POST /treasury/unfreeze — vault+TOTP required
+    if (method === 'POST' && path === '/treasury/unfreeze') {
+        if (!auth.vaultVerified || !auth.totpVerified) {
+            return {
+                status: 403,
+                body: { ok: false, error: 'Unfreeze requires valid vault password + TOTP code' },
+            };
+        }
+        logger.log('Treasury UNFREEZE command received');
+        treasuryState.fundingFrozen = false;
+        treasuryState.freezeReason = null;
+        // Reset circuit breaker counters on unfreeze
+        treasuryState.consecutiveMismatches = 0;
+        treasuryState.consecutiveProviderFailures = 0;
+        await saveTreasuryState();
+        return { status: 200, body: { ok: true, message: 'Funding unfrozen' } };
+    }
+    // GET /treasury/balances — session token only
+    if (method === 'GET' && path === '/treasury/balances') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                data: {
+                    stablecoinBalanceCents: treasuryState.stablecoinBalanceCents,
+                    bankBalanceCents: treasuryState.bankBalanceCents,
+                    totalAvailableCents: treasuryState.stablecoinBalanceCents + treasuryState.bankBalanceCents,
+                    pendingTransferCount: treasuryState.pendingTransferCount,
+                    fundingFrozen: treasuryState.fundingFrozen,
+                },
+            },
+        };
+    }
+    // GET /treasury/funding-status — session token only
+    if (method === 'GET' && path === '/treasury/funding-status') {
+        const pending = await readPendingTransfers();
+        const activePending = pending.filter(t => t.status === 'pending' || t.status === 'processing');
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                data: {
+                    pendingPlans: activePending.length,
+                    pendingTransfers: activePending.map(t => ({
+                        id: t.id,
+                        amountCents: t.amountCents,
+                        status: t.status,
+                        initiatedAt: t.initiatedAt,
+                    })),
+                    runwayDays: treasuryState.runwayDays,
+                    fundingFrozen: treasuryState.fundingFrozen,
+                    freezeReason: treasuryState.freezeReason,
+                    lastOfframpAt: treasuryState.lastOfframpAt,
+                    lastReconciliationAt: treasuryState.lastReconciliationAt,
+                    consecutiveMismatches: treasuryState.consecutiveMismatches,
+                },
+            },
+        };
+    }
+    // GET /treasury/runway — session token only
+    if (method === 'GET' && path === '/treasury/runway') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                data: {
+                    runwayDays: treasuryState.runwayDays,
+                    bankBalanceCents: treasuryState.bankBalanceCents,
+                    stablecoinBalanceCents: treasuryState.stablecoinBalanceCents,
+                    fundingFrozen: treasuryState.fundingFrozen,
+                },
+            },
+        };
+    }
+    // Not a treasury route — return null so the caller falls through
+    return null;
+}

package/dist/wizard/lib/treasury-heartbeat.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Treasury Heartbeat — re-export hub.
+ *
+ * This file was split into focused modules:
+ *   - treasury-io.ts          — State persistence, WAL, transfers, funding plans
+ *   - treasury-circuit-breakers.ts — Circuit breaker evaluation (PRD S13.2)
+ *   - treasury-jobs.ts        — 9 scheduled heartbeat jobs + auto-funding executor
+ *   - treasury-handlers.ts    — Socket request handlers (POST/GET routes)
+ *
+ * All exports are re-exported here for backward compatibility — any file
+ * importing from 'treasury-heartbeat.js' continues to work unchanged.
+ */
+export { isStablecoinConfigured, getTreasuryStateSnapshot, executeTreasuryFreeze, } from './treasury-io.js';
+export type { TreasuryHeartbeatState, PendingTransfer, Logger, WriteStateFn, FreezeFn, } from './treasury-io.js';
+export { evaluateCircuitBreakers, evaluateTransferSlaBreaker, evaluateBillingBreakers, } from './treasury-circuit-breakers.js';
+export type { CircuitBreakerResult, } from './treasury-circuit-breakers.js';
+export { registerTreasuryJobs, } from './treasury-jobs.js';
+export { handleTreasuryRequest, } from './treasury-handlers.js';

package/dist/wizard/lib/treasury-heartbeat.js

@@ -0,0 +1,20 @@
+/**
+ * Treasury Heartbeat — re-export hub.
+ *
+ * This file was split into focused modules:
+ *   - treasury-io.ts          — State persistence, WAL, transfers, funding plans
+ *   - treasury-circuit-breakers.ts — Circuit breaker evaluation (PRD S13.2)
+ *   - treasury-jobs.ts        — 9 scheduled heartbeat jobs + auto-funding executor
+ *   - treasury-handlers.ts    — Socket request handlers (POST/GET routes)
+ *
+ * All exports are re-exported here for backward compatibility — any file
+ * importing from 'treasury-heartbeat.js' continues to work unchanged.
+ */
+// ── treasury-io.ts ───────────────────────────────────
+export { isStablecoinConfigured, getTreasuryStateSnapshot, executeTreasuryFreeze, } from './treasury-io.js';
+// ── treasury-circuit-breakers.ts ─────────────────────
+export { evaluateCircuitBreakers, evaluateTransferSlaBreaker, evaluateBillingBreakers, } from './treasury-circuit-breakers.js';
+// ── treasury-jobs.ts ─────────────────────────────────
+export { registerTreasuryJobs, } from './treasury-jobs.js';
+// ── treasury-handlers.ts ─────────────────────────────
+export { handleTreasuryRequest, } from './treasury-handlers.js';