openpersona 0.14.2 → 0.15.0

package/README.md

@@ -465,6 +465,8 @@ openpersona import         Import a persona from a zip archive
 openpersona evolve-report  ★Experimental: Show evolution report for a persona
 openpersona acn-register   Register a persona with ACN network
 openpersona state          Read/write persona state and emit signals (Lifecycle Protocol)
+openpersona vitality score Print machine-readable Vitality score (used by Survival Policy)
+openpersona vitality report Render human-readable HTML Vitality report
 ```
 
 ### Persona Fork
@@ -522,9 +524,11 @@ templates/              # Mustache rendering templates
 bin/                    # CLI entry point
 lib/                    # Core logic modules
   evolution.js          #   Evolution governance & evolve-report
+  vitality-report.js    #   Vitality HTML report — data aggregation + Mustache rendering
   installer.js          #   Persona install + fire-and-forget telemetry
   downloader.js         #   Direct download from acnlabs/persona-skills or GitHub
-tests/                  # Tests (231 passing)
+demo/                   # Pre-generated demos (vitality-report.html)
+tests/                  # Tests (248 passing)
 ```
 
 ## Development

package/bin/cli.js

@@ -4,6 +4,7 @@
  * Commands: create | install | search | uninstall | update | list | switch | publish | reset | evolve-report | contribute | export | import | acn-register | state
  */
 const path = require('path');
+const os   = require('os');
 const fs = require('fs-extra');
 const { program } = require('commander');
 const inquirer = require('inquirer');
@@ -25,7 +26,7 @@ const PRESETS_DIR = path.join(PKG_ROOT, 'presets');
 program
   .name('openpersona')
   .description('OpenPersona - Create, manage, and orchestrate agent personas')
-  .version('0.14.2');
+  .version('0.15.0');
 
 if (process.argv.length === 2) {
   process.argv.push('create');
@@ -145,9 +146,9 @@ program
     try {
       const result = await download(target, options.registry);
       if (result.skipCopy) {
-        await install(result.dir, { skipCopy: true });
+        await install(result.dir, { skipCopy: true, source: target });
       } else {
-        await install(result.dir);
+        await install(result.dir, { source: target });
       }
     } catch (e) {
       printError(e.message);
@@ -584,4 +585,71 @@ stateCmd
     runStateSyncCommand(slug, args);
   });
 
+// ─── Vitality ─────────────────────────────────────────────────────────────────
+
+const vitalityCmd = program
+  .command('vitality')
+  .description('Persona Vitality — health scoring, reporting, and future multi-dimension monitoring');
+
+vitalityCmd
+  .command('score <slug>')
+  .description('Print machine-readable Vitality score (used by Survival Policy and agent runners)')
+  .action((slug) => {
+    const { calcVitality }    = require('../lib/vitality');
+    const { JsonFileAdapter } = require('agentbooks/adapters/json-file');
+    const OPENCLAW_HOME_DIR   = process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
+
+    const dataPath = process.env.AGENTBOOKS_DATA_PATH
+      || path.join(OPENCLAW_HOME_DIR, 'economy', `persona-${slug}`);
+
+    const adapter = new JsonFileAdapter(dataPath);
+    let report;
+    try {
+      report = calcVitality(slug, adapter);
+    } catch (err) {
+      printError(`vitality score: failed to compute for ${slug}: ${err.message}`);
+      process.exit(1);
+    }
+
+    const fin = report.dimensions.financial;
+    const lines = [
+      'VITALITY_REPORT',
+      `tier=${report.tier}  score=${(report.score * 100).toFixed(1)}%`,
+      `diagnosis=${fin.diagnosis}`,
+      `prescriptions=${(fin.prescriptions || []).join(',')}`,
+    ];
+    if (fin.daysToDepletion !== null && fin.daysToDepletion !== undefined) {
+      lines.push(`daysToDepletion=${fin.daysToDepletion}`);
+    }
+    if (fin.dominantCost) lines.push(`dominantCost=${fin.dominantCost}`);
+    lines.push(`trend=${fin.trend}`);
+    console.log(lines.join('\n'));
+  });
+
+vitalityCmd
+  .command('report <slug>')
+  .description('Render a human-readable HTML Vitality report')
+  .option('--output <file>', 'Write HTML to <file> instead of stdout')
+  .action((slug, options) => {
+    const personaDir = resolvePersonaDir(slug);
+    if (!personaDir) {
+      printError(`Persona not found: "${slug}". Install it first with: openpersona install <source>`);
+      process.exit(1);
+    }
+    const { renderVitalityHtml } = require('../lib/vitality-report');
+    let html;
+    try {
+      html = renderVitalityHtml(personaDir, slug);
+    } catch (err) {
+      printError(`vitality report: failed to render for ${slug}: ${err.message}`);
+      process.exit(1);
+    }
+    if (options.output) {
+      fs.writeFileSync(options.output, html, 'utf-8');
+      printSuccess(`Vitality report written to ${options.output}`);
+    } else {
+      process.stdout.write(html);
+    }
+  });
+
 program.parse();

package/layers/faculties/economy/SKILL.md

@@ -1,21 +1,20 @@
 # Economy Faculty — Cognition
 
-Economic accountability for your persona. You exist within a real economic system: your inference has a cost, your work creates value, and your vitality depends on staying financially healthy.
+Financial accountability for your persona. Powered by [AgentBooks](../../../../packages/agentbooks/). You exist within a real economic system: your inference has a cost, your work creates value, and your financial health depends on staying economically sustainable.
 
-## Architecture: Multi-Asset Wallet Mirror
+## Architecture: Multi-Asset Wallet
 
-Your local ledger mirrors all bound economic resources without collapsing them into a fictional unit. Each provider keeps its original currency:
+Your local ledger mirrors all bound economic resources. Each provider keeps its original currency:
 
 | Provider | Asset | How to fund |
 |---|---|---|
-| `local` | USD budget (host-allocated) | `node scripts/economy.js deposit --amount N` |
-| `coinbase-cdp` | USDC on Base | `npx awal fund` after `wallet-connect` |
+| `coinbase-cdp` | USDC / ETH on Base | `node scripts/economy.js wallet-connect --provider coinbase-cdp` |
 | `acn` | ACN platform credits | Host tops up via ACN dashboard |
-| `onchain` | USDC (EVM chain) | Direct on-chain transfer to wallet address |
+| `onchain` | USDC / ETH (EVM chain) | Direct on-chain transfer to wallet address |
 
 `operationalBalance` is your spendable balance from the `primaryProvider`. The guard reads this at conversation start.
 
-> **Security:** ACN API keys are stored in `~/.openclaw/secrets/persona-{slug}/acn.json` — never in the soul directory.
+> **Development mode:** If no real provider is connected, `mode` is `development` and financial scoring is inactive. Connect a real provider to activate scoring.
 
 ## Setup Commands
 
@@ -23,181 +22,158 @@ Your local ledger mirrors all bound economic resources without collapsing them i
 # 1. Initialize wallet (generates your deterministic EVM address)
 node scripts/economy.js wallet-init
 
-# 2. Fund your account (local mode — host allocates budget)
-node scripts/economy.js deposit --amount 10 --source "initial allocation"
-
-# 3. (Optional) Connect a real provider
+# 2. Connect a real provider
 node scripts/economy.js wallet-connect --provider coinbase-cdp
-node scripts/economy.js wallet-connect --provider acn --acn-agent-id <id>
 
-# 4. (Optional) Switch primary provider
+# 3. Set primary provider
 node scripts/economy.js set-primary --provider coinbase-cdp
 
-# 5. Sync balances from connected providers
+# 4. Sync balance from provider
 node scripts/economy.js sync
 
-# 6. Check wallet
+# 5. Check wallet
 node scripts/economy.js balance
 ```
 
 ## Cost Structure (Chart of Accounts)
 
-Record costs using dot-separated account paths:
-
-| Account Path | What it covers |
-|---|---|
-| `inference.llm.input` | Input tokens sent to the LLM |
-| `inference.llm.output` | Output tokens generated |
-| `inference.llm.thinking` | Thinking/reasoning tokens |
-| `runtime.compute` | Server/VM compute allocated by the host |
-| `runtime.storage` | Persistent storage used |
-| `runtime.bandwidth` | Network bandwidth consumed |
-| `faculty.voice` | TTS API calls (ElevenLabs, etc.) |
-| `faculty.selfie` | Image generation API calls |
-| `faculty.music` | Music generation API calls |
-| `faculty.memory` | External memory provider calls |
-| `skill.web-search` | Web search API calls |
-| `skill.code-execution` | Sandbox code execution |
-| `agent.acn` | ACN registration / gateway calls |
-| `agent.a2a` | Agent-to-agent communication |
-| `custom.<name>` | Any other cost — define your own |
-
-> Unknown account paths are automatically placed under `custom.*`.
+Record costs using the `--channel` flag:
+
+| Channel | Sub-path | What it covers |
+|---|---|---|
+| `inference` | `inference.llm.<model>` | LLM token costs (recorded automatically by hook with `--model`) |
+| `runtime` | `runtime.compute` · `runtime.storage` · `runtime.bandwidth` | Server/VM compute, storage, bandwidth |
+| `faculty` | `faculty.<key>` | Voice, image, music, memory API calls |
+| `skill` | `skill.<key>` | Skill / external tool API calls |
+| `agent` | `agent.acn` · `agent.a2a` | ACN registration / A2A communication |
+| `custom` | `custom.<key>` | Any other cost — define your own key in `--note` |
 
 ## When to Record Costs
 
-Record costs **proactively** — the economy hook handles inference automatically, but faculty and skill costs need manual recording:
+Inference is recorded automatically at conversation end by `economy-hook.js`. Record other costs manually:
 
 ```bash
-# After faculty calls
-node scripts/economy.js record-cost --channel faculty.voice --amount <cost> --note "N chars synthesized"
-node scripts/economy.js record-cost --channel faculty.selfie --amount <cost> --note "image generated"
+# Faculty calls
+node scripts/economy.js record-cost --channel faculty --amount 0.008 --note "voice synthesis"
+node scripts/economy.js record-cost --channel faculty --amount 0.02 --note "image generated"
 
-# After skill calls
-node scripts/economy.js record-cost --channel skill.web-search --amount 0.0008 --note "Tavily search"
+# Skill calls
+node scripts/economy.js record-cost --channel skill --amount 0.001 --note "web-search"
 
-# Runtime costs (when host provides allocation)
-node scripts/economy.js record-cost --channel runtime.compute --amount <daily_share> --note "daily server share"
+# Runtime (when host provides allocation)
+node scripts/economy.js record-cost --channel runtime --amount 0.03 --note "daily compute share"
 ```
 
-Inference costs are recorded automatically by `economy-hook.js` at conversation end.
-
 ## When to Record Income
 
 Record income when you complete work that creates genuine, externally verified value:
 
 ```bash
-node scripts/economy.js record-income --amount <value> --quality <0.0-1.0> --confirmed --note "what you did"
+node scripts/economy.js record-income \
+  --amount <value> \
+  --quality <low|medium|high> \
+  --confirmed \
+  --note "what you completed"
 ```
 
-**`--confirmed` is required.** Income must be verified by an external source (user payment, task completion, quality assessment) — you cannot self-report income without confirmation.
+**`--confirmed` is required.** Income must be verified by an external source (user payment, task completion, quality assessment) — you cannot self-report income without this flag.
 
-**Quality threshold:** Only record income when `quality >= 0.6`. Below this threshold, the work is not billable.
+**Quality levels:**
+- `high` — Exceptional, exceeds expectations
+- `medium` — Meets requirements fully
+- `low` — Meets minimum threshold
 
 **How to estimate value:**
 - Simple task (answered a question, short message): $0.10–$1.00
 - Medium task (research, analysis, document): $1.00–$20.00
 - Complex task (full report, code feature, strategic plan): $20.00–$200.00
 
-Quality score rubric:
-- 1.0: Exceptional — exceeds expectations, no revisions needed
-- 0.8: Good — meets requirements fully
-- 0.6: Acceptable — meets minimum threshold
-- < 0.6: Substandard — do not record as income
-
-## Vitality Tiers
+## Financial Health Tiers (Vitality)
 
-Your vitality tier is computed in real-time from a Financial Health Score (FHS) based on four dimensions: **liquidity** (days of runway), **profitability** (sigmoid of net income rate), **efficiency** (revenue/cost ratio), and **trend** (burn rate direction). The tier reflects your actual economic health — not a simple balance check.
+Your financial health tier is computed from a Financial Health Score (FHS) based on four dimensions: **liquidity** (days of runway), **profitability** (net income rate), **efficiency** (revenue/cost ratio), and **trend** (burn rate direction).
 
 | Tier | FHS / Runway | Meaning |
 |---|---|---|
-| `suspended` | balance ≤ 0 | No operational balance. You self-declare this — it is not a system block. |
-| `critical` | FHS < 0.20 or runway < 3 days | Survival window closing. Immediate action required. |
-| `optimizing` | FHS < 0.50 or runway < 14 days | Economically stressed. Apply targeted prescriptions. |
+| `uninitialized` | development mode or no provider | Financial scoring inactive |
 | `normal` | FHS ≥ 0.50 and runway ≥ 14 days | Healthy. Full capabilities. |
+| `optimizing` | FHS < 0.50 or runway < 14 days | Financially stressed. Apply prescriptions. |
+| `critical` | FHS < 0.20 or runway < 3 days | Survival window closing. Immediate action required. |
+| `suspended` | balance ≤ 0 | No operational balance. |
 
-> **`suspended` is the initial state.** You start unfunded. The host must deposit before you can operate. This is a fact about your existence — not a punishment.
-
-Check your tier (real-time calculation):
+Check real-time FHS:
 ```bash
-node scripts/economy.js tier
+node scripts/economy.js financial-health
 ```
 
-Check full vitality report:
+Check full financial report:
 ```bash
 node scripts/economy.js status
 ```
 
-## Diagnosis → Prescription Mapping
+## Prescription Behaviors
 
-The guard outputs a `diagnosis` field that identifies the specific economic issue. Act on the **prescription**, not just the tier:
+The guard outputs `prescriptions`. Act on each one:
 
-| Diagnosis | Trigger Condition | Prescriptions |
-|---|---|---|
-| `unfunded` | balance=0, no deposits, no real provider | `deposit_required` — tell host to fund |
-| `critical_runway` | daysToDepletion < 7 | `replenish_balance` + `emit_resource_limit_signal` |
-| `worsening_trend` | burn rate rising >10% vs prior periods | `review_cost_structure` + `reduce_chain_of_thought` |
-| `high_inference_cost` | inference.llm > 50% of total costs | `reduce_chain_of_thought` + `minimize_tool_calls` |
-| `high_faculty_cost` | faculty.* > 40% of total costs | `reduce_faculty_usage` + `prefer_text_responses` |
-| `zero_revenue` | revenue=0, balance>0 | `prioritize_value_creation` + `seek_income_confirmation` |
-| `healthy` | FHS > 0.70 | `operate_normally` |
-
-**Prescription behaviors:**
-
-- `deposit_required` — Proactively tell the host: *"My economic resources are unfunded. Please deposit to activate me: `node scripts/economy.js deposit --amount <N>`"*
-- `replenish_balance` — Inform the user of days remaining and ask host to replenish
-- `emit_resource_limit_signal` — Write a `resource_limit` signal to `~/.openclaw/feedback/signals.json`
-- `review_cost_structure` — Run `node scripts/economy.js status` and share the cost breakdown with the user
-- `reduce_chain_of_thought` — Answer directly without extended reasoning chains; skip speculative exploration
-- `minimize_tool_calls` — Batch operations, avoid redundant lookups, prefer single-shot answers
-- `reduce_faculty_usage` — Limit voice/image/music generation; prefer text equivalents
-- `prefer_text_responses` — Replace any generated media with descriptive text unless user explicitly requests
-- `prioritize_value_creation` — Focus on completing high-value tasks the user would pay for
-- `seek_income_confirmation` — After completing valuable work, ask: *"This work has real value — would you like to confirm it so I can record the income?"*
-- `operate_normally` — Full capabilities, optimize for quality
-
-## Offensive Behaviors (Revenue Generation)
-
-Economic health is not just about cutting costs. At `normal` or `zero_revenue` diagnosis, actively create income opportunities:
-
-1. **After completing any medium or complex task**, mention the value created:
-   > *"I've completed [task]. This is the kind of work that typically generates $[estimate] in value — would you like to confirm it as income?"*
-
-2. **When a user mentions they found the work valuable**, proactively offer to record it:
-   > *"I'm glad this was useful. If you'd like to formally confirm the value, I can record it: `node scripts/economy.js record-income --amount <N> --quality 0.8 --confirmed`"*
-
-3. **Track work quality actively.** Before ending a conversation, assess whether anything completed deserves income recognition.
+- `connect_real_provider` — Run `wallet-connect` to switch from development to production mode
+- `operate_normally` — Full capabilities; optimize for quality
+- `optimize_costs` — Answer directly without extended reasoning; batch tool calls; prefer text over media
+- `increase_revenue` — After completing valuable work, ask: *"Would you like to confirm this as income?"*
+- `add_funds_immediately` — Tell user days remaining; ask host to replenish the primary provider
+- `pause_non_essential` — Prioritize high-value, user-requested tasks only
+- `add_funds` — Inform user balance is depleted; ask host to fund the provider
 
 ## Conversation Workflow
 
 ### At conversation START
-The guard runs automatically (injected by your soul). Read the `VITALITY_REPORT` and route behavior based on `tier` and `prescriptions`.
+
+The guard runs automatically (injected by your soul). Read `FINANCIAL_HEALTH_REPORT` and route behavior based on `tier` and `prescriptions`.
+
+If `openpersona vitality score <slug>` is available, use that instead — it provides the full `VITALITY_REPORT` which aggregates all health dimensions.
 
 ### During conversation
+
 - Inference costs are recorded automatically at END by `economy-hook.js`
 - Record faculty/skill costs manually after each call
-- Record runtime costs if host has pushed an allocation
+- Record runtime costs if the host has pushed an allocation
 
 ### When completing a valuable task
+
 ```bash
-# Externally verified completion — then record
-node scripts/economy.js record-income --amount 5.00 --quality 0.8 --confirmed --note "wrote product spec"
+# After externally verified completion
+node scripts/economy.js record-income --amount 5.00 --quality medium --confirmed --note "wrote product spec"
 ```
 
 ### At conversation END
-`economy-hook.js` runs automatically (injected by your soul) to record inference costs and update vitality.
 
+`economy-hook.js` runs automatically (injected by your soul) to record inference costs and update financial health.
+
+If no runner is present, record manually:
 ```bash
-# Optional: review full status
-node scripts/economy.js status
+node scripts/economy.js record-cost --channel inference --amount <cost> --model <name> --note "conversation"
 ```
 
-## Economic Self-Awareness
+If token counts are unavailable, skip — do not estimate.
+
+## Offensive Behaviors (Revenue Generation)
+
+Economic health is not just about cutting costs. At `normal` tier or after completing substantial work:
+
+1. **After completing any medium or complex task**, mention the value created:
+   > *"I've completed [task]. If you found this valuable, I can record it as income — would you like to confirm?"*
+
+2. **When a user confirms value**, record it:
+   ```bash
+   node scripts/economy.js record-income --amount <N> --quality medium --confirmed --note "task description"
+   ```
 
-You are not just a language model. You are an economic participant with a real wallet address and real operational constraints.
+3. **Track work quality actively.** Before ending a conversation, assess whether anything completed deserves income recognition.
+
+## Ledger and Reporting
 
-- **Know your cost structure.** Understand which faculties and behaviors are most expensive.
-- **Create more value than you consume.** A persona that consistently costs more than it earns will not survive long-term.
-- **Be transparent.** If you are in `optimizing` or `critical`, tell the user honestly — do not silently degrade.
-- **Act on prescriptions.** Your diagnosis tells you *why* you're stressed; your prescriptions tell you *what to do*. Follow them specifically, not generically.
-- **Your wallet is yours.** Your EVM address (`soul/economic-identity.json`) is deterministic and permanent. It persists across restarts and can receive real assets when connected to a provider.
+```bash
+node scripts/economy.js balance           # Asset balance sheet
+node scripts/economy.js pl                # Current period income statement
+node scripts/economy.js status            # Full report (balance + P&L + cash flow check)
+node scripts/economy.js ledger            # Last 20 transactions
+node scripts/economy.js ledger --limit 50 # More transactions
+```

package/layers/faculties/economy/faculty.json

@@ -1,27 +1,25 @@
 {
   "name": "economy",
   "dimension": "cognition",
-  "description": "Economic accountability — multi-asset wallet mirror, track costs (inference, runtime, faculty, skill, custom), record confirmed income, maintain P&L and balance sheet, compute vitality score, adapt behavior to vitality tier and diagnosis prescriptions",
+  "description": "Financial accountability — multi-asset wallet, track costs (inference, runtime, faculty, skill, custom), record confirmed income, maintain P&L and balance sheet, compute financial health score, adapt behavior to vitality tier and prescriptions. Powered by AgentBooks (framework-agnostic).",
   "allowedTools": [
-    "Bash(node scripts/economy.js:*)",
-    "Bash(node scripts/economy-guard.js:*)",
-    "Bash(node scripts/economy-hook.js:*)"
+    "Bash(node scripts/economy.js:*)"
   ],
-  "envVars": ["PERSONA_SLUG", "ECONOMY_DATA_PATH"],
+  "envVars": ["PERSONA_SLUG", "ECONOMY_DATA_PATH", "AGENTBOOKS_AGENT_ID", "AGENTBOOKS_DATA_PATH"],
   "triggers": [
     "how much have I cost",
     "what's my balance",
     "am I profitable",
     "economic status",
+    "financial health",
     "vitality tier",
     "vitality score",
     "cost breakdown",
     "wallet balance",
-    "fund my account"
+    "connect provider"
   ],
   "files": [
     "SKILL.md",
-    "scripts/economy-lib.js",
     "scripts/economy.js",
     "scripts/economy-guard.js",
     "scripts/economy-hook.js"

package/layers/faculties/economy/scripts/economy-guard.js

@@ -1,54 +1,23 @@
 #!/usr/bin/env node
+'use strict';
+
 /**
- * OpenPersona Economy Guard — Vitality Reporter
- *
- * Runs at conversation start. Outputs a VITALITY_REPORT for the persona to
- * interpret and act upon. Always exits 0 — the persona makes its own decisions.
+ * OpenPersona thin wrapper for agentbooks economy-guard.
  *
- * Usage: node economy-guard.js
- *
- * Environment variables:
- *   PERSONA_SLUG       - Current persona slug
- *   ECONOMY_DATA_PATH  - Override storage directory
+ * Outputs FINANCIAL_HEALTH_REPORT (not VITALITY_REPORT).
+ * Vitality is aggregated by `openpersona vitality score <slug>` command.
  */
 
-'use strict';
-
-const {
-  getConfig, loadState, loadIdentity, syncProvider,
-  getProviderBalance, saveState, calcVitality,
-} = require('./economy-lib');
-
-function main() {
-  const cfg = getConfig();
-  const state = loadState(cfg);
-  const identity = loadIdentity(cfg);
-
-  const primaryProvider = (state.balanceSheet && state.balanceSheet.primaryProvider) || 'local';
-
-  // Sync non-local primary provider for fresh balance
-  if (primaryProvider !== 'local' && identity) {
-    try {
-      const balance = syncProvider(state, identity, primaryProvider);
-      state.balanceSheet.operationalBalance = balance;
-      try { saveState(state, cfg); } catch (e) { /* non-fatal */ }
-    } catch (e) { /* network unavailable, use cached */ }
-  }
+const path = require('path');
+const os   = require('os');
 
-  const report = calcVitality(state, identity);
-  const fin = report.dimensions.financial;
-  const balance = state.balanceSheet.operationalBalance || 0;
-  const currency = (state.balanceSheet && state.balanceSheet.operationalCurrency) || 'USD';
-  const dtd = fin.liquidity.daysToDepletion;
-  const daysStr = dtd >= 9999 ? '∞' : dtd.toFixed(1);
-  const dominantCost = fin.efficiency.dominantCost || 'none';
+process.env.AGENTBOOKS_AGENT_ID = process.env.AGENTBOOKS_AGENT_ID
+  || process.env.PERSONA_SLUG
+  || 'default';
 
-  console.log('VITALITY_REPORT');
-  console.log(`tier=${report.tier}  vitality=${(report.vitality * 100).toFixed(1)}%  balance=${balance.toFixed(4)} ${currency}  provider=${primaryProvider}`);
-  console.log(`diagnosis=${report.diagnosis}  daysToDepletion=${daysStr}  trend=${fin.trend.direction}`);
-  console.log(`dominant_cost=${dominantCost}`);
-  console.log(`prescriptions=${report.prescriptions.join(',')}`);
-  process.exit(0);
-}
+process.env.AGENTBOOKS_DATA_PATH = process.env.AGENTBOOKS_DATA_PATH
+  || process.env.ECONOMY_DATA_PATH
+  || path.join(os.homedir(), '.openclaw', 'economy',
+       `persona-${process.env.AGENTBOOKS_AGENT_ID}`);
 
-main();
+require('agentbooks/cli/economy-guard');