@ola-893/agentpay-cli 0.1.0 → 0.4.0

package/src/cli.mjs

@@ -1,144 +1,275 @@
+import { copyFlags, copyPositionals, runCopyCommand } from './copy-commands.mjs';
+import { selectedAgent } from './agents.mjs';
 import { parseArgs } from 'node:util';
 import { fileURLToPath } from 'node:url';
-import { demoScenario } from '@ola-893/agentpay-core';
+import { readFile } from 'node:fs/promises';
 import { projectPath, initProject, readProject, liveProfile, gatewayFor, setPayments } from './config.mjs';
+import { showSettings, setRuntime, setService, setInference, setLimits, reconcileLimits, usdc } from './settings.mjs';
 
-const help = `AgentPay 0.1.0 — payment guardrails for agents on NEAR
+const version = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8')).version;
+const help = `AgentPay ${version} — configure and run agents with native NEAR payment streams
 
-  agentpay init --quick                        Offline config, no keys/network
-  agentpay demo                                Always offline; simulated decisions
-  agentpay doctor                              Read-only configuration checks
-  agentpay install cursor|codex [--dry-run]     Project MCP server and guidance
-  agentpay mcp                                 Stdio MCP using project mode
-  agentpay ui [--no-open] [--recording testnet|sandbox]
+Named agents and copy trading:
+  agentpay agent create NAME | list | use NAME | show [NAME]
+  agentpay agent setup --network testnet [--deploy]
+  agentpay agent run [--once]                 Run publication and/or follow a subscribed feed
+  agentpay task list | enable ACTIVITY | disable ACTIVITY
+  agentpay task enable spot-trading --intents-agent-id ID [--live] [--confidential]
+  agentpay task run spot-trading --from ASSET --to ASSET --amount-raw UNITS [--execute]
+  agentpay publish set --url ORIGIN --rate USDC_PER_SECOND --recipient SELLER.testnet [--duration SECONDS]
+  agentpay publish start | status | history | stop
+  agentpay earnings show | claim --from VAULT --recipient-key PATH
+  agentpay discover [--activity ACTIVITY] [--id PUBLISHER --url ORIGIN]
+  agentpay copy PUBLISHER [--url ORIGIN]      Preview a signed offer for free
+  agentpay copy start PUBLISHER [--url ORIGIN]
+  agentpay copy mode observe|approve|auto
+  agentpay copy pending | approve ACTION | reject ACTION
+  agentpay copy pause | resume | stop | status | history
+  agentpay guard set payment --max-5xx 3 --max-health-failures 2 --reuse true
+  agentpay guard set execution --assets A,B --input-asset A --max-input-raw UNITS --copy-input-raw UNITS
+  agentpay guard set feed --stale-seconds 45 --feed-failures 3
+  agentpay guard show
+  agentpay fund USDC --owner-key PATH | withdraw USDC --owner-key PATH
+  agentpay balance | status
+  Spot trading uses NEAR Intents Agent Connect. Subscription escrow uses NEAR testnet.
 
-Explicit live setup (existing deployment, testnet only):
+Setup (NEAR testnet, funded owner account required):
+  agentpay init --network testnet
+  agentpay init --network testnet --owner-id YOUR.testnet --owner-key /path/owner.json --deploy
   agentpay init --network testnet --deployment /path/deployment.json
-  agentpay payments --enable                    Allow this profile to pay
-  agentpay payments --disable                   Disable OPEN; closure stays available
-  agentpay demo --pay [--fixture]               Real testnet session, then close
-  agentpay close --session SESSION_ID           Approved closure after restart
-  agentpay reconcile                           Read-only chain reconciliation
+  agentpay fund --amount 100000 --owner-key /path/owner.json  Raw USDC units
 
-Common: --project PATH, --json, --help, --version
-Local signing trusts the operator host. TEE isolation and gas sponsorship are not implemented.
+Configure payment and service guardrails:
+  agentpay config show
+  agentpay config limits --budget 0.10 --max-stream 0.01 --max-rate 0.0001 --max-duration 1000 --owner-key /path/owner.json
+  agentpay config set --max-5xx 3 --max-transport-errors 2 --max-health-failures 2 --idle-timeout 60 --max-requests 100 --reuse true --poll-seconds 10 --close-on-exit true
+  agentpay config reconcile                  Reconcile an uncertain owner policy update
+  agentpay service set --url https://api.example.com --request-path /research --health-path /health --quote-path /quote --tiers basic,premium
+  agentpay service serve --repository ./YOUR_REPOSITORY --port 5380
+                                              Serve actual repository analysis using this profile's public vault settings
+                                              Optional --deployment /path/public-service.json; no signing keys are read
+  agentpay payments --enable|--disable       Disabling OPEN preserves closure
+
+Connect inference, then run an agent:
+  agentpay inference set --base-url http://localhost:11434/v1 --model YOUR_MODEL
+                                              Optional --max-output-tokens N --timeout-seconds 120 (10-600)
+  agentpay inference models --provider near-ai  List current models and tool/privacy metadata
+  agentpay inference set --provider near-ai --model MODEL_ID
+                                                Uses NEAR_AI_API_KEY; default output cap 2048 tokens
+  agentpay inference set --base-url https://api.openai.com/v1 --model YOUR_MODEL --api-key-env OPENAI_API_KEY
+  agentpay agent run --prompt "Use the paid API to research my question."
+  agentpay install cursor|codex [--dry-run]   Use that harness's existing inference
+  agentpay install mcp                       Print stdio config for other MCP clients
+  agentpay mcp                               Stdio tools and background health monitor
+
+Operate the same streams directly:
+  agentpay request --tier basic              Actual guarded API request; opens/reuses as needed
+  agentpay stream check [--tier basic]       Read-only admission/health decision
+  agentpay stream open --tier basic          Check policy, then submit OPEN
+  agentpay stream status                     On-chain vault/session state
+  agentpay stream close [--session ID]       Close and return unused escrow
+  agentpay monitor                           Monitor health/idle limits until stopped
+  agentpay reconcile                         Reconcile uncertain OPEN/CLOSE
+  agentpay doctor                            Read-only key, RPC, balance and policy checks
+  agentpay verify [--run /path/run.json]      Verify saved testnet receipts (read-only)
+  agentpay ui [--run /path/run.json] [--no-open] Replay captured real NEAR runs
+
+Common: --project PATH, --agent NAME, --json, --help, --version
+Financial flags and positional fund/withdraw use decimal USDC. Legacy fund --amount uses raw units.
+Only AgentPay-compatible paid APIs are supported. Inference must support OpenAI-compatible chat tool calls, or run through an MCP harness.
+One service and one active stream per profile. Monitor/agent/MCP must be running for automatic health and idle closure; the contract always caps accrual at lease expiry.
+Local signing trusts the host. No TEE, gas sponsor or production security guarantee.
 `;
+const integer = value => { if (!/^[0-9]+$/.test(value || '')) throw new Error('Expected a positive integer.'); return Number(value); };
+const boolean = value => { if (!['true', 'false'].includes(value)) throw new Error('Use true or false.'); return value === 'true'; };
 
 export async function run(argv) {
-  const { values: v, positionals: p } = parseArgs({ args: argv, allowPositionals: true, strict: true, options: {
-    quick: { type: 'boolean' }, json: { type: 'boolean' }, help: { type: 'boolean' }, version: { type: 'boolean' },
-    project: { type: 'string', default: '.' }, network: { type: 'string' }, deployment: { type: 'string' }, 'enable-payments': { type: 'boolean' },
-    enable: { type: 'boolean' }, disable: { type: 'boolean' }, 'dry-run': { type: 'boolean' }, 'no-open': { type: 'boolean' },
-    recording: { type: 'string', default: 'testnet' }, port: { type: 'string', default: '0' }, pay: { type: 'boolean' }, fixture: { type: 'boolean' }, session: { type: 'string' },
+  const strings = ['agent', 'activity', 'id', 'activities', 'rate', 'intents-agent-id', 'intents-key-env', 'intents-grant-env', 'from', 'to', 'amount-raw', 'nova-group', 'nova-account', 'nova-network', 'nova-key-env', 'performance-file', 'recipient-key', 'assets', 'input-asset', 'max-input-raw', 'copy-input-raw', 'max-age', 'max-slippage-bps', 'max-notional', 'stale-seconds', 'feed-failures', 'network', 'deployment', 'session', 'owner-id', 'owner-key', 'recipient', 'amount', 'budget', 'max-stream', 'max-rate', 'max-duration', 'max-5xx', 'max-transport-errors', 'max-health-failures', 'idle-timeout', 'max-requests', 'reuse', 'poll-seconds', 'close-on-exit', 'url', 'health-path', 'quote-path', 'request-path', 'tiers', 'base-url', 'model', 'api-key-env', 'max-steps', 'prompt', 'tier', 'query', 'thinking', 'failure-cooldown', 'provider', 'reasoning-effort', 'max-output-tokens', 'repository', 'basic-rate', 'premium-rate', 'duration', 'run', 'timeout-seconds'];
+  const booleans = ['once', 'live', 'confidential', 'execute', 'json', 'help', 'version', 'enable-payments', 'enable', 'disable', 'dry-run', 'no-open', 'deploy'];
+  const { values: v, positionals: p, tokens } = parseArgs({ args: argv, allowPositionals: true, strict: true, tokens: true, options: {
+    ...Object.fromEntries(strings.map(k => [k, { type: 'string' }])), ...Object.fromEntries(booleans.map(k => [k, { type: 'boolean' }])),
+    project: { type: 'string', default: '.' }, recording: { type: 'string', default: 'testnet' }, port: { type: 'string', default: '0' },
+    'vault-name': { type: 'string', default: 'agentpay' }, 'agent-name': { type: 'string', default: 'research-agent' }, rpc: { type: 'string', default: 'https://test.rpc.fastnear.com' }, service: { type: 'string', default: 'http://127.0.0.1:5321' },
   } });
   const emit = value => process.stdout.write(typeof value === 'string' ? value + '\n' : JSON.stringify(value, (_, item) => typeof item === 'bigint' ? item.toString() : item, 2) + '\n');
-  if (v.version) return emit('0.1.0');
+  if (v.version) return emit(version);
   if (v.help || !p.length) return emit(help);
-  if (p.length > (p[0] === 'install' ? 2 : 1)) throw new Error('Unexpected positional arguments. See --help.');
-  const project = await projectPath(v.project);
+  const allowed = {
+    ...copyFlags,
+    init: 'network deployment enable-payments owner-id owner-key recipient vault-name agent-name rpc service deploy',
+    'config:set': 'max-5xx max-transport-errors max-health-failures idle-timeout max-requests reuse poll-seconds close-on-exit failure-cooldown',
+    'config:limits': 'budget max-stream max-rate max-duration recipient owner-key', 'config:show': '', 'config:reconcile': '', config: '',
+    'service:set': 'url recipient health-path quote-path request-path tiers', 'service:show': '', service: '',
+    'service:serve': 'repository port deployment basic-rate premium-rate duration',
+    'inference:set': 'provider base-url model api-key-env max-steps thinking reasoning-effort max-output-tokens timeout-seconds', 'inference:models': 'provider', 'inference:show': '', inference: '', 'agent:run': 'prompt max-steps once rpc',
+    request: 'tier query', 'stream:check': 'tier', 'stream:open': 'tier', 'stream:status': '', 'stream:close': 'session',
+    monitor: '', reconcile: '', close: 'session', verify: 'rpc run', fund: 'amount owner-key', doctor: '', payments: 'enable disable',
+    install: 'dry-run', mcp: '', ui: 'no-open recording port run',
+  };
+  const grouped = ['config', 'service', 'inference', 'agent', 'stream', 'task', 'publish', 'earnings', 'guard', 'copy'];
+  let command = grouped.includes(p[0]) && p[1] ? `${p[0]}:${p[1]}` : p[0];
+  if (p[0] === 'copy' && /^ap_[a-f0-9]{64}$/.test(p[1] ?? '')) command = 'copy:preview';
+  const maxPositionals = copyPositionals.has(command) ? 3 : grouped.includes(p[0]) || ['install', 'fund', 'withdraw'].includes(p[0]) ? 2 : 1;
+  if (p.length > maxPositionals) throw new Error('Unexpected positional arguments. See --help.');
+  const common = ['project', 'agent', 'json', 'help', 'version'];
+  const provided = tokens.filter(token => token.kind === 'option' && !common.includes(token.name)).map(token => token.name);
+  if (Object.hasOwn(allowed, command)) {
+    const flags = new Set(allowed[command].split(' '));
+    for (const flag of provided) if (!flags.has(flag)) throw new Error(`--${flag} is not supported by ${p.join(' ')}.`);
+  }
+  const workspace = await projectPath(v.project);
+  const identityOnly = ['agent:create', 'agent:use', 'agent:list'].includes(command);
+  const agent = identityOnly ? null : await selectedAgent(workspace, command === 'agent:show' ? p[2] ?? v.agent : v.agent);
+  const project = agent?.path ?? workspace;
+  if (command === 'agent:run' && (!v.prompt && provided.includes('max-steps') || v.prompt && (v.once || provided.includes('rpc')))) throw new Error('Use --prompt with --max-steps, or the copy runner with --once and --rpc.');
+  if (Object.hasOwn(copyFlags, command) || (command === 'agent:run' && !v.prompt) || (command === 'reconcile' && agent)) {
+    const result = await runCopyCommand(command, p, v, workspace, agent, emit, provided);
+    if (command === 'reconcile' && !result.resolved) process.exitCode = 1;
+    if (result !== undefined) return emit(result);
+    return;
+  }
   switch (p[0]) {
     case 'init': {
-      if (!v.quick && v.network !== 'testnet') throw new Error('Use --quick or --network testnet with --deployment.');
-      return emit(await initProject(project, { quick: v.quick, deployment: v.deployment, enablePayments: v['enable-payments'] }));
+      if (v.network && v.network !== 'testnet') throw new Error('Only native NEAR testnet is supported.');
+      if (!v.deployment) {
+        if (v['enable-payments']) throw new Error('Setup leaves payments disabled; enable them separately after funding.');
+        const { setupTestnet } = await import('./setup.mjs');
+        const result = await setupTestnet(project, { ownerId: v['owner-id'], ownerKeyFile: v['owner-key'], recipientId: v.recipient, vaultLabel: v['vault-name'], agentLabel: v['agent-name'], rpcUrl: v.rpc, serviceUrl: v.service, deploy: v.deploy });
+        if (result.readyToDeploy === false) process.exitCode = 1;
+        return emit(result);
+      }
+      return emit(await initProject(project, { deployment: v.deployment, enablePayments: v['enable-payments'] }));
+    }
+    case 'config': {
+      if (p[1] === 'show' || !p[1]) return emit(await showSettings(project));
+      if (p[1] === 'reconcile') { const result = await reconcileLimits(project); if (!result.resolved) process.exitCode = 1; return emit(result); }
+      if (p[1] === 'limits') {
+        const patch = {};
+        for (const [flag, key] of [['budget','budget'], ['max-stream','max_deposit'], ['max-rate','max_rate']]) if (v[flag] !== undefined) patch[key] = usdc(v[flag]);
+        if (v['max-duration']) patch.max_duration_seconds = integer(v['max-duration']);
+        if (v.recipient) patch.recipients = v.recipient.split(',');
+        return emit(await setLimits(project, patch, v['owner-key']));
+      }
+      if (p[1] !== 'set') throw new Error('Use config show, set, limits or reconcile.');
+      const patch = {};
+      for (const [flag, key] of [['max-5xx','maxConsecutive5xx'], ['max-transport-errors','maxConsecutiveTransportErrors'], ['max-health-failures','maxConsecutiveHealthFailures'], ['idle-timeout','idleTimeoutSeconds'], ['max-requests','maxRequestsPerStream'], ['poll-seconds','healthPollSeconds'], ['failure-cooldown','failureCooldownSeconds']]) if (v[flag] !== undefined) patch[key] = integer(v[flag]);
+      for (const [flag, key] of [['reuse','reuseStream'], ['close-on-exit','closeOnExit']]) if (v[flag] !== undefined) patch[key] = boolean(v[flag]);
+      return emit(await setRuntime(project, patch));
     }
-    case 'demo': {
-      if (!v.pay) {
-        if (v.fixture) throw new Error('--fixture requires explicit --pay.');
-        const demo = await demoScenario();
-        if (v.json) return emit(demo);
-        return emit(`Offline simulation — no keys, network or blockchain transactions.\n${demo.events.map(e => `${e.decision}: ${e.reason || 'SESSION_CLOSED'}`).join('\n')}\n10 API requests reused one simulated session.\nSimulated six-decimal USDC: deposit 10000, earned 20, refunded 9980.`);
+    case 'service': {
+      if (p[1] === 'show' || !p[1]) return emit((await showSettings(project)).service);
+      if (p[1] === 'serve') {
+        if (!/^\d+$/.test(v.port) || Number(v.port) > 65535) throw new Error('Invalid port.');
+        const { readConfig } = await import('@ola-893/agentpay-core/internal-config');
+        const config = await readConfig(v.deployment || (await liveProfile(project)).configPath);
+        const { startRepositoryService } = await import('./repository-service.mjs');
+        const service = await startRepositoryService(config, { repository: v.repository, port: Number(v.port) || 5380,
+          rates: { basic: usdc(v['basic-rate'] || '0.000010'), premium: usdc(v['premium-rate'] || '0.000200') }, durationSeconds: v.duration ? integer(v.duration) : 1000 });
+        emit({ listening: service.origin, pid: process.pid, ...service.summary, faultInjection: 'Send SIGUSR1 to this process to toggle explicitly injected paid-request 503s; health stays healthy.' });
+        let injected = false;
+        const toggle = () => { injected = !injected; service.setRequestUnavailable(injected); emit({ injected503: injected, healthUnchanged: true }); };
+        process.on('SIGUSR1', toggle);
+        const stop = () => { process.removeListener('SIGUSR1', toggle); void service.close(); };
+        process.once('SIGINT', stop); process.once('SIGTERM', stop);
+        return;
       }
-      return emit(await liveDemo(project, v.fixture));
+      if (p[1] !== 'set') throw new Error('Use service show, set or serve.');
+      const patch = {};
+      for (const [flag, key] of [['url','url'], ['recipient','recipient'], ['health-path','healthPath'], ['quote-path','quotePath'], ['request-path','requestPath']]) if (v[flag] !== undefined) patch[key] = v[flag];
+      if (v.tiers) patch.tiers = v.tiers.split(',');
+      return emit(await setService(project, patch));
+    }
+    case 'inference': {
+      if (p[1] === 'show' || !p[1]) return emit((await liveProfile(project)).inference || { configured: false });
+      if (p[1] === 'models') { const { listInferenceModels } = await import('./inference.mjs'); return emit(await listInferenceModels({ provider: v.provider })); }
+      if (p[1] !== 'set') throw new Error('Use inference show, set or models.');
+      return emit(await setInference(project, { provider: v.provider, baseUrl: v['base-url'], model: v.model, apiKeyEnv: v['api-key-env'], maxSteps: v['max-steps'] ? integer(v['max-steps']) : undefined,
+        ...(v.thinking !== undefined ? { thinking: boolean(v.thinking) } : {}),
+        ...(v['reasoning-effort'] !== undefined ? { reasoningEffort: v['reasoning-effort'] } : {}),
+        ...(v['timeout-seconds'] !== undefined ? { timeoutSeconds: integer(v['timeout-seconds']) } : {}),
+        ...(v['max-output-tokens'] !== undefined ? { maxOutputTokens: integer(v['max-output-tokens']) } : {}) }));
+    }
+    case 'agent': {
+      if (p[1] !== 'run') throw new Error('Use agent run --prompt "...".');
+      const profile = await liveProfile(project);
+      if (!profile.inference) throw new Error('Configure inference first with agentpay inference set, or install the MCP integration in your harness.');
+      const client = await gatewayFor(project);
+      const controller = new AbortController();
+      const stop = () => controller.abort(new Error('AGENT_INTERRUPTED'));
+      process.once('SIGINT', stop); process.once('SIGTERM', stop);
+      try { const { runAgent } = await import('./agent.mjs'); return await runAgent(client, { ...profile.inference, ...(v['max-steps'] ? { maxSteps: integer(v['max-steps']) } : {}) }, { prompt: v.prompt, signal: controller.signal, emit }); }
+      finally { process.removeListener('SIGINT', stop); process.removeListener('SIGTERM', stop); await client.dispose(); }
+    }
+    case 'request':
+    case 'stream':
+    case 'monitor':
+    case 'reconcile':
+    case 'close': {
+      if (p[0] === 'stream' && !['check', 'open', 'status', 'close'].includes(p[1])) throw new Error('Use stream check, open, status or close.');
+      const client = await gatewayFor(project);
+      try {
+        if (p[0] === 'reconcile') { const result = await client.reconcile(); if (!result.resolved) process.exitCode = 1; return emit(result); }
+        if (p[0] === 'request') { const { createToolHandlers } = await import('@ola-893/agentpay-core/tools'); return emit(await createToolHandlers(client).agentpay_fetch({ tier: v.tier || client.service.tiers[0], ...(v.query !== undefined ? { query: v.query } : {}) })); }
+        if (p[0] === 'monitor') {
+          const { startMonitor } = await import('@ola-893/agentpay-core/monitor');
+          let finish; const done = new Promise(resolve => { finish = resolve; });
+          const stop = () => finish();
+          process.once('SIGINT', stop); process.once('SIGTERM', stop);
+          const monitor = startMonitor(client, { onEvent: emit, onError: error => { emit({ error: error.message }); process.exitCode = 1; finish(); } });
+          emit({ monitoring: true, policy: client.runtimePolicy });
+          try { await done; } finally { process.removeListener('SIGINT', stop); process.removeListener('SIGTERM', stop); await monitor.stop(); if (client.runtimePolicy.closeOnExit) emit(await client.close()); }
+          return;
+        }
+        if (p[0] === 'close' || p[1] === 'close') return emit(await client.close({ sessionId: v.session }));
+        if (p[1] === 'status') return emit(await client.status());
+        const checked = await client.check({ tier: v.tier });
+        if (p[1] === 'check') return emit(checked);
+        if (checked.decision === 'CONTINUE') return emit({ ...checked, reused: true });
+        if (checked.decision !== 'OPEN') { process.exitCode = 1; return emit(checked); }
+        return emit({ ...await client.open({ approvalId: checked.approvalId }), monitoring: 'Run agentpay monitor for automatic health and idle closure between requests.' });
+      } finally { await client.dispose(); }
+    }
+    case 'verify': {
+      const { verifyPublicRun } = await import('@ola-893/agentpay-core/internal-evidence');
+      const { bundledWasm, publicRecording } = await import('./setup.mjs');
+      return emit(await verifyPublicRun({ recordingFile: v.run || publicRecording, wasmFile: bundledWasm, rpcUrl: v.rpc }));
+    }
+    case 'fund': {
+      if (p[1] && v.amount) throw new Error('Choose a decimal positional amount or legacy --amount.');
+      const { fundProject } = await import('./setup.mjs');
+      return emit(await fundProject(project, { ownerKeyFile: v['owner-key'], amount: p[1] ? usdc(p[1]) : v.amount, decimal: Boolean(p[1]) }));
     }
     case 'doctor': {
-      const config = await readProject(project);
-      const [major, minor, patch] = process.versions.node.split('.').map(Number);
-      const nodeOK = major > 22 || (major === 22 && (minor > 22 || (minor === 22 && patch >= 2)));
-      if (!nodeOK) throw new Error('Node 22.22.2 or newer is required.');
-      if (config.mode === 'offline') return emit({ ok: true, mode: 'offline', node: process.versions.node, walletRequired: false, networkChecked: false, next: 'agentpay demo' });
+      if (agent) {
+        const { agentSetupState, readAgentState } = await import('./agents.mjs');
+        const [setup, state] = await Promise.all([agentSetupState(agent), readAgentState(agent)]);
+        if (!setup.configured) return emit({ ok: false, agentId: agent.id, setup, next: 'agentpay agent setup --network testnet' });
+        if (state.tradePending) process.exitCode = 1;
+      }
+      await readProject(project);
       const profile = await liveProfile(project);
       const { inspectNearProfile } = await import('@ola-893/agentpay-core/near');
-      const { summary } = await inspectNearProfile(profile.configPath, profile.stateRoot);
-      const ok = !summary.pendingIntent && !summary.executorBusyOrInterrupted;
+      const { summary, config } = await inspectNearProfile(profile.configPath, profile.stateRoot);
+      const ok = !process.exitCode && !summary.pendingIntent && !summary.executorBusyOrInterrupted && !summary.policyUpdatePending;
       if (!ok) process.exitCode = 1;
-      return emit({ ok, node: process.versions.node, paymentsEnabled: profile.paymentsEnabled, ...summary });
-    }
-    case 'payments': {
-      if (Boolean(v.enable) === Boolean(v.disable)) throw new Error('Choose exactly one of --enable or --disable.');
-      return emit(await setPayments(project, v.enable));
+      return emit({ ok, node: process.versions.node, paymentsEnabled: profile.paymentsEnabled, inferenceConfigured: Boolean(profile.inference), runtimePolicy: config.runtimePolicy, ...summary });
     }
+    case 'payments': { if (Boolean(v.enable) === Boolean(v.disable)) throw new Error('Choose exactly one of --enable or --disable.'); return emit(await setPayments(project, v.enable)); }
     case 'install': {
+      if (p[1] === 'mcp') { const { mcpServer } = await import('./install.mjs'); return emit({ mcpServers: { agentpay: mcpServer(workspace, fileURLToPath(new URL('../bin/agentpay.mjs', import.meta.url)), { agent: agent?.name }) } }); }
       const { installAgent } = await import('./install.mjs');
-      return emit(await installAgent(p[1], project, fileURLToPath(new URL('../bin/agentpay.mjs', import.meta.url)), { dryRun: v['dry-run'] }));
-    }
-    case 'mcp': {
-      const { startMcp } = await import('./mcp.mjs');
-      return startMcp(await gatewayFor(project));
+      return emit(await installAgent(p[1], workspace, fileURLToPath(new URL('../bin/agentpay.mjs', import.meta.url)), { dryRun: v['dry-run'], agent: agent?.name }));
     }
+    case 'mcp': { const { startMcp } = await import('./mcp.mjs'); return startMcp(await gatewayFor(project)); }
     case 'ui': {
       if (!/^\d+$/.test(v.port) || Number(v.port) > 65535) throw new Error('Invalid port.');
       const { startUi, openBrowser } = await import('./ui.mjs');
-      const ui = await startUi({ port: Number(v.port), recording: v.recording });
-      emit({ url: ui.url, mode: 'recorded', recording: v.recording, readOnly: true });
+      const ui = await startUi({ port: Number(v.port), recording: v.recording, runFile: v.run });
+      emit({ url: ui.url, mode: 'replay-of-real-near-run', recording: v.recording, readOnly: true });
       if (!v['no-open']) openBrowser(ui.url);
-      process.once('SIGINT', () => void ui.close());
-      process.once('SIGTERM', () => void ui.close());
+      process.once('SIGINT', () => void ui.close()); process.once('SIGTERM', () => void ui.close());
       return;
     }
-    case 'reconcile':
-    case 'close': {
-      const client = await gatewayFor(project);
-      try {
-        if (p[0] === 'reconcile') {
-          if (!client.reconcile) throw new Error('Reconciliation applies only to live profiles.');
-          const result = await client.reconcile();
-          if (!result.resolved) process.exitCode = 1;
-          return emit(result);
-        }
-        return emit(await client.close({ sessionId: v.session }));
-      } finally { await client.dispose(); }
-    }
     default: throw new Error('Unknown command. Run agentpay --help.');
   }
 }
-
-async function liveDemo(project, fixture) {
-  const config = await readProject(project);
-  if (config.mode !== 'testnet') throw new Error('--pay requires an explicitly configured testnet profile.');
-  const profile = await liveProfile(project);
-  if (!profile.paymentsEnabled) throw new Error('PAYMENTS_DISABLED');
-  const { readConfig } = await import('@ola-893/agentpay-core/internal-config');
-  const runtime = await readConfig(profile.configPath);
-  let provider;
-  if (fixture) {
-    if (!['127.0.0.1', 'localhost'].includes(new URL(runtime.serviceUrl).hostname)) throw new Error('Fixture provider must use loopback.');
-    const { startProvider } = await import('@ola-893/agentpay-core/internal-provider');
-    provider = await startProvider(runtime);
-  }
-  let client, active;
-  try {
-    client = await gatewayFor(project);
-    const opened = await client.check({ tier: 'basic' });
-    if (opened.decision !== 'OPEN') throw new Error(opened.reason || 'ADMISSION_DENIED');
-    const openedSession = await client.open({ approvalId: opened.approvalId });
-    active = openedSession;
-    const { guardedFetch } = await import('@ola-893/agentpay-core');
-    const request = guardedFetch(fetch, { client });
-    for (let i = 0; i < 10; i++) {
-      const r = await request(`${client.serviceUrl}/research`, { signal: AbortSignal.timeout(60000) });
-      if (!r.ok) throw new Error('PROVIDER_REQUEST_FAILED');
-      await r.arrayBuffer();
-    }
-    const continued = await client.check();
-    const closed = await client.close({ sessionId: active.sessionId });
-    active = null;
-    const denied = await client.check({ tier: 'premium' });
-    return { mode: 'testnet', fixture: Boolean(fixture), requestsReusingSession: 10, admission: opened, opened: openedSession, continued, closed, denied, providerPayout: 'claimable; no provider key loaded' };
-  } finally {
-    if (active) {
-      try { await client.close({ sessionId: active.sessionId }); } catch { process.stderr.write('Closure unconfirmed. Run doctor/reconcile; owner recovery or expiry settlement may be needed.\n'); }
-    }
-    await client?.dispose();
-    await provider?.close();
-  }
-}

package/src/config.mjs

@@ -2,7 +2,6 @@ import { homedir } from 'node:os';
 import { join, resolve, dirname } from 'node:path';
 import { createHash } from 'node:crypto';
 import { mkdir, realpath, stat } from 'node:fs/promises';
-import { OfflineGateway } from '@ola-893/agentpay-core';
 import { readOptional, atomicWrite, safeTarget } from './files.mjs';
 
 export const configHome = () => resolve(process.env.AGENTPAY_HOME || join(homedir(), '.agentpay'));
@@ -11,23 +10,17 @@ const idFor = project => createHash('sha256').update(project).digest('hex');
 
 export async function readProject(project) {
   const text = await readOptional(await safeTarget(project, '.agentpay/config.json'));
-  if (text === null) throw new Error('Project is not initialized. Run agentpay init --quick.');
+  if (text === null) throw new Error('Project is not initialized. Run agentpay init --network testnet.');
   const config = JSON.parse(text);
   if (config.version !== 1 || !['offline', 'testnet'].includes(config.mode)) throw new Error('Unsupported AgentPay configuration.');
   if (config.mode === 'testnet' && config.profileId !== idFor(project)) throw new Error('Live profile belongs to a different project; initialize this project explicitly.');
   return config;
 }
 
-export async function initProject(project, { quick = false, deployment, enablePayments = false } = {}) {
+export async function initProject(project, { deployment, enablePayments = false } = {}) {
   const path = await safeTarget(project, '.agentpay/config.json');
   if (await readOptional(path)) throw new Error('Project already initialized. Use a separate project for another mode; agentpay payments changes live enablement.');
-  if (quick) {
-    if (deployment || enablePayments) throw new Error('--quick is offline and cannot enable payments or import credentials.');
-    const config = { version: 1, mode: 'offline' };
-    await atomicWrite(path, JSON.stringify(config, null, 2) + '\n');
-    return { ...config, keysGenerated: false, next: 'agentpay demo' };
-  }
-  if (!deployment) throw new Error('Choose --quick or --network testnet --deployment /absolute/path/deployment.json.');
+  if (!deployment) throw new Error('Use --network testnet --deployment /absolute/path/deployment.json.');
   const { readConfig, readKey } = await import('@ola-893/agentpay-core/internal-config');
   const sourcePath = resolve(deployment);
   const source = await readConfig(sourcePath);
@@ -49,7 +42,7 @@ export async function initProject(project, { quick = false, deployment, enablePa
     if (await readOptional(file)) throw new Error('Credential already exists; refusing to replace it.');
     await atomicWrite(file, JSON.stringify({ account_id: credential.accountId, public_key: credential.publicKey, private_key: credential.privateKey }));
   }
-  const runtime = Object.fromEntries(['network', 'rpcUrl', 'serviceUrl', 'vaultId', 'agentId', 'ownerId', 'recipientId', 'tokenId'].map(k => [k, source[k]]));
+  const runtime = Object.fromEntries(['network', 'rpcUrl', 'serviceUrl', 'vaultId', 'agentId', 'ownerId', 'recipientId', 'tokenId', 'runtimePolicy', 'service'].map(k => [k, source[k]]));
   const configPath = join(directory, 'deployment.json');
   await atomicWrite(configPath, JSON.stringify({ ...runtime, agentKeyFile, policyKeyFile }, null, 2));
   await atomicWrite(profilePath, JSON.stringify({ version: 1, paymentsEnabled: Boolean(enablePayments) }));
@@ -69,13 +62,14 @@ export async function liveProfile(project) {
 
 export async function setPayments(project, enabled) {
   const profile = await liveProfile(project);
-  await atomicWrite(profile.file, JSON.stringify({ version: 1, paymentsEnabled: Boolean(enabled) }));
+  const { file, configPath, stateRoot, ...saved } = profile;
+  await atomicWrite(profile.file, JSON.stringify({ ...saved, paymentsEnabled: Boolean(enabled) }));
   return { mode: 'testnet', paymentsEnabled: Boolean(enabled) };
 }
 
 export async function gatewayFor(project) {
   const config = await readProject(project);
-  if (config.mode === 'offline') return new OfflineGateway();
+  if (config.mode === 'offline') throw new Error('A native NEAR testnet profile is required. Initialize a new project with agentpay init --network testnet.');
   const { createNearGateway } = await import('@ola-893/agentpay-core/near');
-  return createNearGateway(await liveProfile(project));
+  return createNearGateway({ ...await liveProfile(project), paymentsEnabled: async () => Boolean((await liveProfile(project)).paymentsEnabled) });
 }

package/src/copy-activity.mjs

@@ -0,0 +1,56 @@
+import { createHash } from 'node:crypto';
+import { usdc } from './settings.mjs';
+
+export const activities = Object.freeze({
+  'spot-trading': 'Mirror an eligible spot swap.',
+  'staking-moves': 'Follow validator or staking pool allocations.',
+  'liquidity-ranges': 'Mirror concentrated-liquidity ranges.',
+  'prediction-markets': 'Mirror outcome positions.',
+  'portfolio-rebalance': 'Follow portfolio target weights.',
+  'yield-reallocation': 'Follow lending or yield-vault allocations.',
+  'reward-reinvestment': 'Compound rewards following a published strategy.',
+});
+
+export const spot = 'spot-trading';
+export const assetId = value => typeof value === 'string' && /^[a-z0-9][a-z0-9:._-]{0,155}$/i.test(value);
+export const rawAmount = value => typeof value === 'string' && /^[1-9][0-9]{0,37}$/.test(value);
+
+export function spotOrder({ from, to, amount }) {
+  if (!assetId(from) || !assetId(to) || from === to || !rawAmount(amount)) throw new Error('Specify distinct --from and --to asset IDs and --amount-raw in the input asset’s atomic units.');
+  return { origin_asset: from, destination_asset: to, amount };
+}
+
+export function executionPolicy(flags, previous = {}) {
+  const assets = flags.assets?.split(',') ?? previous.assets;
+  const maxInput = flags['max-input-raw'] ?? previous.maxInput;
+  const inputAsset = flags['input-asset'] ?? previous.inputAsset;
+  const fixedInput = flags['copy-input-raw'] ?? previous.fixedInput;
+  const maxAge = Number(flags['max-age'] ?? previous.maxAge ?? 60);
+  const slippageBps = Number(flags['max-slippage-bps'] ?? previous.slippageBps ?? 50);
+  if (!assets?.length || assets.length > 32 || !assets.every(assetId) || !assets.includes(inputAsset) || !rawAmount(maxInput) || !rawAmount(fixedInput) || BigInt(fixedInput) > BigInt(maxInput)) throw new Error('Set --assets, --input-asset, --max-input-raw and --copy-input-raw. Use one input asset so caps have a consistent unit.');
+  if (!Number.isInteger(maxAge) || maxAge < 1 || maxAge > 3600 || !Number.isInteger(slippageBps) || slippageBps < 0 || slippageBps > 500) throw new Error('Use --max-age 1–3600 seconds and --max-slippage-bps 0–500.');
+  return { assets: [...new Set(assets)], inputAsset, maxInput, fixedInput, maxAge, slippageBps,
+    ...(flags['max-notional'] ? { maxNotionalRawUSDC: usdc(flags['max-notional']) } : previous.maxNotionalRawUSDC ? { maxNotionalRawUSDC: previous.maxNotionalRawUSDC } : {}) };
+}
+
+export function proposedOrder(action, policy, now = Date.now()) {
+  if (!policy) return { reason: 'EXECUTION_POLICY_REQUIRED' };
+  if (action.at > now + 5000 || now - action.at > policy.maxAge * 1000 || now >= action.expiresAt) return { reason: 'ACTION_EXPIRED' };
+  if (action.from !== policy.inputAsset || !policy.assets.includes(action.to)) return { reason: 'ASSET_NOT_ALLOWED' };
+  return { order: spotOrder({ from: action.from, to: action.to, amount: policy.fixedInput }) };
+}
+
+export function checkQuote(quote, order, action, policy) {
+  if (!rawAmount(quote.amountOut) || !rawAmount(quote.amountIn) || quote.amountIn !== order.amount) return 'UNUSABLE_QUOTE';
+  const expected = BigInt(action.amountOut) * BigInt(order.amount);
+  const observed = BigInt(quote.amountOut) * BigInt(action.amountIn);
+  if (observed * 10000n < expected * BigInt(10000 - policy.slippageBps)) return 'PRICE_MOVED';
+  if (policy.maxNotionalRawUSDC) {
+    let usd;
+    try { usd = BigInt(usdc(String(quote.amountInUsd))); } catch { return 'USD_PRICE_UNAVAILABLE'; }
+    if (usd > BigInt(policy.maxNotionalRawUSDC)) return 'NOTIONAL_LIMIT';
+  }
+  return null;
+}
+
+export const operationKey = (agentId, actionId) => createHash('sha256').update(`${agentId}:${actionId}`).digest('hex');