@txfence/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1281 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/simulate.ts
+import { Command as Command2 } from "commander";
+import { resolve } from "path";
+
+// src/action-options.ts
+import "commander";
+function addActionOptions(cmd) {
+  return cmd.option("--kind <kind>", "action kind: swap, transfer, contract_call (required)").option("--chain <chain>", "target chain: ethereum, solana, etc. (required)").option("--to <address>", "recipient address (for transfer) or output token (for swap)").option("--from-token <token>", "input token symbol (for swap)").option("--from-amount <amt>", "input amount as integer (for swap, in token base units)").option("--token <token>", "token symbol (for transfer)").option("--amount <amt>", "amount as integer in base units (for transfer)").option("--via <address>", "router contract address (for swap)").option("--slippage <bps>", "max slippage in basis points (for swap, default 50)", "50").option("--contract <address>", "contract address (for contract_call)").option("--method <name>", "method name (for contract_call)").option("--value-token <token>", "value token (for contract_call)").option("--value-amount <amt>", "value amount in base units (for contract_call)");
+}
+function buildActionFromOptions(opts) {
+  const chain = opts["chain"];
+  const kind = opts["kind"];
+  if (kind === "transfer") {
+    const to = opts["to"];
+    const token = opts["token"];
+    const amount = opts["amount"];
+    if (to === void 0 || token === void 0 || amount === void 0) {
+      throw new Error("transfer requires --to, --token, and --amount");
+    }
+    return {
+      kind: "transfer",
+      chain,
+      token: { token, amount: BigInt(amount), decimals: 18 },
+      to
+    };
+  }
+  if (kind === "swap") {
+    const to = opts["to"];
+    const fromToken = opts["fromToken"];
+    const fromAmount = opts["fromAmount"];
+    const via = opts["via"];
+    if (to === void 0 || fromToken === void 0 || fromAmount === void 0 || via === void 0) {
+      throw new Error("swap requires --to, --from-token, --from-amount, and --via");
+    }
+    return {
+      kind: "swap",
+      chain,
+      from: { token: fromToken, amount: BigInt(fromAmount), decimals: 18 },
+      to,
+      via,
+      maxSlippage: Number(opts["slippage"] ?? "50")
+    };
+  }
+  if (kind === "contract_call") {
+    const contract = opts["contract"];
+    const method = opts["method"];
+    if (contract === void 0 || method === void 0) {
+      throw new Error("contract_call requires --contract and --method");
+    }
+    const valueToken = opts["valueToken"];
+    const valueAmount = opts["valueAmount"];
+    const base = {
+      kind: "contract_call",
+      chain,
+      contract,
+      method,
+      args: []
+    };
+    if (valueToken !== void 0 && valueAmount !== void 0) {
+      return { ...base, value: { token: valueToken, amount: BigInt(valueAmount), decimals: 18 } };
+    }
+    return base;
+  }
+  throw new Error("--kind must be one of: swap, transfer, contract_call");
+}
+
+// src/format.ts
+import { formatExecutionFailureReason } from "@txfence/core";
+function formatSimulationResult(result) {
+  const lines = [
+    `Simulation: ${result.success ? "SUCCESS" : "FAILED"}`,
+    `Chain:      ${result.chain}`,
+    `Block:      ${result.simulatedAtBlock}`,
+    `Gas:        ${result.gasEstimate.toString()} (buffer: ${result.gasBufferApplied}x)`,
+    `Coverage:   ${result.coverageLevel}`,
+    `Caveats:    ${result.caveats.length > 0 ? result.caveats.join(", ") : "none"}`
+  ];
+  return lines.join("\n");
+}
+function formatPolicyEvaluation(evaluation) {
+  const lines = [
+    `Policy: ${evaluation.passed ? "PASSED" : "FAILED"}`,
+    `Checks: ${evaluation.checksRun.join(", ")}`
+  ];
+  if (!evaluation.passed && evaluation.rejectionReason !== void 0) {
+    lines.push(`Reason: ${evaluation.rejectionReason}`);
+  }
+  return lines.join("\n");
+}
+function formatExecutionResult(result) {
+  switch (result.status) {
+    case "success": {
+      const r = result.receipt;
+      return [
+        "Transaction: SUCCESS",
+        `Hash:        ${r.txHash}`,
+        `Block:       ${r.confirmedAtBlock}`,
+        `Gas used:    ${r.gasUsed.toString()}`,
+        formatPolicyEvaluation(r.policyEvaluation)
+      ].join("\n");
+    }
+    case "policy_rejected":
+      return [
+        "Policy: REJECTED",
+        `Reason: ${result.evaluation.rejectionReason ?? "unknown"}`,
+        `Checks: ${result.evaluation.checksRun.join(", ")}`
+      ].join("\n");
+    case "simulation_failed":
+      return [
+        "Simulation: FAILED",
+        formatSimulationResult(result.simulation)
+      ].join("\n");
+    case "simulation_stale":
+      return [
+        "Status:     STALE SIMULATION",
+        `Stale by:   ${result.stalenessMs}ms`,
+        `Threshold:  ${result.simulation.simulatedAtBlock} (simulated at block)`,
+        "Action:     Re-simulate before retrying."
+      ].join("\n");
+    case "approval_timeout":
+      return [
+        "Status: APPROVAL REQUIRED",
+        "The action exceeds the human approval threshold. Resubmit with explicit approval."
+      ].join("\n");
+    case "execution_failed":
+      return [
+        "Status: FAILED",
+        `Reason: ${formatExecutionFailureReason(result.reason)}`
+      ].join("\n");
+  }
+}
+
+// src/commands/simulate.ts
+import { loadConfig } from "@txfence/mcp";
+function makeSimulateCommand() {
+  const cmd = new Command2("simulate").description("Simulate an on-chain action without executing it").option("--config <path>", "path to txfence.config.ts", "./txfence.config.ts").option("--rpc <url>", "RPC endpoint override");
+  addActionOptions(cmd);
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig(resolve(opts["config"] ?? "./txfence.config.ts"));
+      const action = buildActionFromOptions(opts);
+      const adapter = config.adapters[action.chain];
+      if (adapter === void 0) {
+        throw new Error("no adapter for chain: " + action.chain);
+      }
+      const rpcUrl = opts["rpc"] ?? config.rpcUrls[action.chain];
+      if (rpcUrl === void 0) {
+        throw new Error("no rpcUrl for chain: " + action.chain);
+      }
+      const result = await adapter.simulate(action, action.chain, rpcUrl);
+      console.log(formatSimulationResult(result));
+      process.exit(0);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/check-policy.ts
+import { Command as Command3 } from "commander";
+import { resolve as resolve2 } from "path";
+import { loadConfig as loadConfig2 } from "@txfence/mcp";
+import { evaluate, validateConfig } from "@txfence/core";
+function makeCheckPolicyCommand() {
+  const cmd = new Command3("check-policy").description("Evaluate an action against the configured policy without simulation or execution").option("--config <path>", "path to txfence.config.ts", "./txfence.config.ts");
+  addActionOptions(cmd);
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig2(resolve2(opts["config"] ?? "./txfence.config.ts"));
+      const validation = validateConfig(config.policy);
+      if (validation.errors.length > 0) {
+        console.error("\nPolicy configuration errors (must fix):");
+        for (const err of validation.errors) {
+          console.error(`  [ERROR] ${err.field}: ${err.message}`);
+        }
+      }
+      if (validation.warnings.length > 0) {
+        console.warn("\nPolicy configuration warnings (should fix):");
+        for (const warn of validation.warnings) {
+          console.warn(`  [WARN]  ${warn.field}: ${warn.message}`);
+        }
+      }
+      if (!validation.valid) {
+        console.error("\nPolicy has errors. Fix them before running agents.");
+        process.exit(1);
+      }
+      if (validation.warnings.length > 0) {
+        console.warn("");
+      }
+      const action = buildActionFromOptions(opts);
+      const boundAction = { action, policy: config.policy };
+      const evaluation = evaluate(boundAction);
+      console.log(formatPolicyEvaluation(evaluation));
+      process.exit(evaluation.passed ? 0 : 1);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/submit.ts
+import { Command as Command4 } from "commander";
+import { resolve as resolve3 } from "path";
+import { loadConfig as loadConfig3 } from "@txfence/mcp";
+import { runPipeline } from "@txfence/core";
+import { executeEvmAction } from "@txfence/evm";
+function makeSubmitCommand() {
+  const cmd = new Command4("submit").description("Run the full txfence pipeline. Dry run by default.").option("--config <path>", "path to txfence.config.ts", "./txfence.config.ts").option("--dry-run", "simulate the full pipeline without executing (default)", true).option("--execute", "execute the transaction (requires signer in config)");
+  addActionOptions(cmd);
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig3(resolve3(opts["config"] ?? "./txfence.config.ts"));
+      const action = buildActionFromOptions(opts);
+      const dryRun = !opts["execute"];
+      if (!dryRun && config.signer === void 0) {
+        console.error("execution requires a signer configured in txfence.config.ts");
+        process.exit(1);
+      }
+      const executor = dryRun ? void 0 : (action2, chainId, rpcUrl, evaluation, simulation) => executeEvmAction(action2, chainId, rpcUrl, config.signer, evaluation, simulation);
+      const result = await runPipeline(
+        action,
+        config.policy,
+        config.adapters,
+        config.rpcUrls,
+        executor
+      );
+      if (!dryRun && result.status === "execution_failed" && result.reason.code === "no_executor") {
+        console.error("signing not available for this chain");
+        process.exit(1);
+      }
+      console.log(formatExecutionResult(result));
+      process.exit(result.status === "success" ? 0 : 1);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/receipt.ts
+import { Command as Command5 } from "commander";
+import { resolve as resolve4 } from "path";
+import { createPublicClient, http } from "viem";
+import { getViemChain } from "@txfence/evm";
+import { loadConfig as loadConfig4 } from "@txfence/mcp";
+function makeReceiptCommand() {
+  const cmd = new Command5("receipt").description("Retrieve on-chain details for a transaction by hash").option("--config <path>", "path to txfence.config.ts", "./txfence.config.ts").requiredOption("--hash <txHash>", "transaction hash").requiredOption("--chain <chain>", "chain the transaction was submitted to").option("--rpc <url>", "RPC endpoint override");
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig4(resolve4(opts["config"] ?? "./txfence.config.ts"));
+      const rpcUrl = opts["rpc"] ?? config.rpcUrls[opts["chain"]];
+      if (rpcUrl === void 0) {
+        console.error("no rpcUrl for chain: " + opts["chain"]);
+        process.exit(1);
+      }
+      let chain;
+      try {
+        chain = getViemChain(opts["chain"]);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+      const client = createPublicClient({ chain, transport: http(rpcUrl) });
+      const receipt = await client.getTransactionReceipt({ hash: opts["hash"] });
+      console.log(`Transaction: ${opts["hash"]}`);
+      console.log(`Chain:       ${opts["chain"]}`);
+      console.log(`Status:      ${receipt.status}`);
+      console.log(`Block:       ${receipt.blockNumber.toString()}`);
+      console.log(`Gas used:    ${receipt.gasUsed.toString()}`);
+      process.exit(0);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/init.ts
+import { Command as Command6 } from "commander";
+import { existsSync, writeFileSync } from "fs";
+import { resolve as resolve5 } from "path";
+function makeInitCommand() {
+  const cmd = new Command6("init").description("Scaffold a txfence.config.ts in the current directory").option("--force", "overwrite existing config file");
+  cmd.action((opts) => {
+    const configPath = resolve5("./txfence.config.ts");
+    if (existsSync(configPath) && !opts.force) {
+      console.error("txfence.config.ts already exists. Use --force to overwrite.");
+      process.exit(1);
+    }
+    const template = `import { defineConfig, env } from '@txfence/mcp'
+import { simulateEvmAction, executeEvmAction, privateKeySigner } from '@txfence/evm'
+
+export default defineConfig({
+  // chains this agent is allowed to operate on
+  chains: ['ethereum'],
+
+  // chain adapters: one per chain
+  adapters: {
+    ethereum: { simulate: simulateEvmAction },
+  },
+
+  // RPC endpoints: use a private endpoint in production
+  rpcUrls: {
+    ethereum: 'https://ethereum.publicnode.com',
+  },
+
+  // base policy: all agent actions are evaluated against this
+  policy: {
+    chains: ['ethereum'],
+
+    // maximum spend per transaction
+    maxSpendPerTx: { token: 'USDC', amount: 1000n, decimals: 6 },
+
+    // contracts this agent is allowed to interact with
+    // add entries with optional bytecodeHash and ownerAddress for metadata verification
+    allowedContracts: [],
+
+    // require simulation before every execution
+    requireSimulation: true,
+
+    // minimum gas buffer multiplier applied to simulation estimates
+    gasBufferMultiplier: 1.2,
+
+    // transactions above this threshold require human approval
+    humanApprovalThreshold: { token: 'USDC', amount: 10000n, decimals: 6 },
+
+    // how long to wait for human approval before cancelling (ms)
+    humanApprovalTimeoutMs: 30000,
+
+    // cap lock mode: per-agent (default) or shared (for multi-agent environments)
+    capLockMode: 'per-agent',
+  },
+
+  // signer: required for live execution (dryRun: false)
+  // never hardcode private keys -- use environment variables
+  // signer: privateKeySigner(env('AGENT_PRIVATE_KEY') as \`0x\${string}\`),
+})
+`;
+    writeFileSync(configPath, template, "utf-8");
+    console.log("created txfence.config.ts");
+    console.log("");
+    console.log("next steps:");
+    console.log("  1. add your RPC endpoint to rpcUrls");
+    console.log("  2. add allowed contracts to policy.allowedContracts");
+    console.log("  3. set AGENT_PRIVATE_KEY in your .env file and uncomment the signer");
+    console.log("  4. run: txfence check-policy --kind transfer --chain ethereum --to 0x... --token ETH --amount 1000000000000000000");
+    process.exit(0);
+  });
+  return cmd;
+}
+
+// src/commands/diff.ts
+import { Command as Command7 } from "commander";
+import { resolve as resolve6 } from "path";
+import { readFileSync } from "fs";
+import { loadConfig as loadConfig5 } from "@txfence/mcp";
+import { diffPolicies, createTestActions } from "@txfence/core";
+function makeDiffCommand() {
+  const cmd = new Command7("diff").description("Compare two policy configurations and show which actions are affected").requiredOption("--config-a <path>", "path to the current txfence config").requiredOption("--config-b <path>", "path to the proposed txfence config").option("--actions-file <path>", "JSON file containing actions to test (array of Action objects)").option("--generate-actions", "auto-generate test actions from policy A");
+  cmd.action(async (opts) => {
+    try {
+      const configA = await loadConfig5(resolve6(opts["configA"]));
+      const configB = await loadConfig5(resolve6(opts["configB"]));
+      let actions = [];
+      if (opts["actionsFile"] !== void 0) {
+        const filePath = opts["actionsFile"];
+        const raw = JSON.parse(readFileSync(resolve6(filePath), "utf-8"));
+        if (!Array.isArray(raw)) {
+          console.error("actions file must be a JSON array");
+          process.exit(1);
+        }
+        actions = raw.map((a) => ({ action: a }));
+      } else if (opts["generateActions"] !== void 0) {
+        actions = createTestActions(configA.policy);
+      } else {
+        console.error("provide --actions-file or --generate-actions");
+        process.exit(1);
+      }
+      const diff = diffPolicies({
+        policyA: configA.policy,
+        policyB: configB.policy,
+        actions
+      });
+      console.log("\nPolicy Diff Summary");
+      console.log("===================");
+      console.log(`Total actions tested:        ${diff.summary.total}`);
+      console.log(`Changed:                     ${diff.summary.changed}`);
+      console.log(`  Newly allowed:             ${diff.summary.newlyAllowed}`);
+      console.log(`  Newly rejected:            ${diff.summary.newlyRejected}`);
+      console.log(`  Rejection reason changed:  ${diff.summary.rejectionReasonChanged}`);
+      console.log(`Unchanged:                   ${diff.summary.unchanged}`);
+      if (diff.summary.requiresSimulation > 0) {
+        console.log(
+          `
+WARNING: ${diff.summary.requiresSimulation} action(s) have simulation-dependent checks that were skipped (no simulationResult provided)`
+        );
+      }
+      if (diff.summary.changed === 0) {
+        console.log("\nNo changes detected.");
+        process.exit(0);
+      }
+      console.log("\nChanged Actions");
+      console.log("===============");
+      for (const result of diff.results.filter((r) => r.changed)) {
+        const act = result.action;
+        const actionDesc = act.kind === "transfer" ? `transfer ${act.token.amount} ${act.token.token} on ${act.chain}` : act.kind === "swap" ? `swap ${act.from.amount} ${act.from.token} on ${act.chain}` : `contract_call ${act.contract} on ${act.chain}`;
+        console.log(`
+[${result.direction?.toUpperCase()}] ${actionDesc}`);
+        console.log(
+          `  Policy A: ${result.evaluationA.passed ? "PASSED" : `REJECTED (${result.evaluationA.rejectionReason})`}`
+        );
+        console.log(
+          `  Policy B: ${result.evaluationB.passed ? "PASSED" : `REJECTED (${result.evaluationB.rejectionReason})`}`
+        );
+        if (result.changedChecks.length > 0) {
+          console.log(`  Changed checks: ${result.changedChecks.map((c) => c.checkName).join(", ")}`);
+        }
+      }
+      process.exit(diff.summary.newlyRejected > 0 ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/dry-run.ts
+import { Command as Command8 } from "commander";
+import { resolve as resolve7 } from "path";
+import { loadConfig as loadConfig6 } from "@txfence/mcp";
+import { runDryRun } from "@txfence/core";
+function makeDryRunCommand() {
+  const cmd = new Command8("dry-run").description("Run the full pipeline without executing \u2014 shows what would happen").option("--config <path>", "path to txfence.config.ts", "./txfence.config.ts");
+  addActionOptions(cmd);
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig6(resolve7(opts["config"] ?? "./txfence.config.ts"));
+      const action = buildActionFromOptions(opts);
+      const result = await runDryRun(
+        action,
+        config.policy,
+        config.adapters,
+        config.rpcUrls
+      );
+      console.log("\n=== Dry Run Report ===\n");
+      console.log(`Action:        ${action.kind} on ${action.chain}`);
+      console.log(`Would proceed: ${result.wouldProceed ? "YES" : "NO"}`);
+      console.log("");
+      console.log("Policy evaluation:");
+      console.log(`  Result:  ${result.evaluation.passed ? "PASSED" : "FAILED"}`);
+      console.log(`  Checks:  ${result.evaluation.checksRun.join(", ")}`);
+      if (result.evaluation.rejectionReason !== void 0) {
+        console.log(`  Rejected: ${result.evaluation.rejectionReason}`);
+      }
+      if (result.simulation !== void 0) {
+        console.log("");
+        console.log("Simulation:");
+        console.log(`  Success:  ${result.simulation.success}`);
+        console.log(`  Coverage: ${result.simulation.coverageLevel}`);
+        console.log(`  Gas est:  ${result.simulation.gasEstimate}`);
+        if (result.simulation.caveats.length > 0) {
+          console.log(`  Caveats:  ${result.simulation.caveats.join(", ")}`);
+        }
+      }
+      console.log("");
+      console.log(`Approval required: ${result.approvalRequired ? "YES" : "no"}`);
+      if (result.approvalThreshold !== void 0) {
+        console.log(`  Threshold: ${result.approvalThreshold.amount} ${result.approvalThreshold.token}`);
+      }
+      console.log(`Cap lock available: ${result.capLockAvailable ? "yes" : "NO"}`);
+      if (result.blockers.length > 0) {
+        console.log("");
+        console.log("Blockers:");
+        for (const blocker of result.blockers) {
+          console.log(`  ${formatBlocker(blocker)}`);
+        }
+      }
+      console.log("");
+      process.exit(result.wouldProceed ? 0 : 1);
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+function formatBlocker(blocker) {
+  switch (blocker.kind) {
+    case "policy_rejected":
+      return `[BLOCKED] Policy rejected: ${blocker.reason}`;
+    case "simulation_failed":
+      return "[BLOCKED] Simulation failed";
+    case "simulation_stale":
+      return `[BLOCKED] Simulation stale by ${blocker.stalenessMs}ms`;
+    case "approval_required":
+      return `[BLOCKED] Human approval required (threshold: ${blocker.thresholdAmount} ${blocker.thresholdToken})`;
+    case "cap_lock_unavailable":
+      return `[BLOCKED] Cap lock unavailable: ${blocker.capId}`;
+    default: {
+      const _ = blocker;
+      return "";
+    }
+  }
+}
+
+// src/commands/policy-snapshot.ts
+import { Command as Command9 } from "commander";
+import { resolve as resolve8 } from "path";
+import { loadConfig as loadConfig7 } from "@txfence/mcp";
+import { createPolicyVersion } from "@txfence/core";
+function makePolicySnapshotCommand() {
+  const cmd = new Command9("policy-snapshot").description("Print the version ID and hash for the active policy config").requiredOption("--config <path>", "path to txfence config").option("--label <label>", "human-readable label for this version").option("--author <author>", "author of this version").option("--json", "output as JSON");
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig7(resolve8(opts["config"]));
+      const version = createPolicyVersion(config.policy, {
+        ...typeof opts["label"] === "string" ? { label: opts["label"] } : {},
+        ...typeof opts["author"] === "string" ? { author: opts["author"] } : {}
+      });
+      if (opts["json"] === true) {
+        console.log(JSON.stringify({
+          id: version.id,
+          ...version.label !== void 0 ? { label: version.label } : {},
+          ...version.author !== void 0 ? { author: version.author } : {},
+          createdAt: version.createdAt,
+          policy: {
+            chains: version.policy.chains,
+            maxSpendPerTx: {
+              token: version.policy.maxSpendPerTx.token,
+              amount: version.policy.maxSpendPerTx.amount.toString(),
+              decimals: version.policy.maxSpendPerTx.decimals
+            },
+            requireSimulation: version.policy.requireSimulation,
+            gasBufferMultiplier: version.policy.gasBufferMultiplier,
+            allowedContracts: version.policy.allowedContracts.length
+          }
+        }, null, 2));
+      } else {
+        console.log("\n=== Policy Snapshot ===\n");
+        console.log(`ID:      ${version.id}`);
+        if (version.label !== void 0) console.log(`Label:   ${version.label}`);
+        if (version.author !== void 0) console.log(`Author:  ${version.author}`);
+        console.log(`Created: ${new Date(version.createdAt).toISOString()}`);
+        console.log("");
+        console.log("Policy summary:");
+        console.log(`  Chains:              ${version.policy.chains.join(", ")}`);
+        console.log(`  Max spend per tx:    ${version.policy.maxSpendPerTx.amount} ${version.policy.maxSpendPerTx.token}`);
+        console.log(`  Require simulation:  ${version.policy.requireSimulation}`);
+        console.log(`  Gas buffer:          ${version.policy.gasBufferMultiplier}x`);
+        console.log(`  Allowed contracts:   ${version.policy.allowedContracts.length}`);
+        console.log("");
+        console.log("Use this ID to reference this policy version in audit queries.");
+      }
+      process.exit(0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/intent.ts
+import { Command as Command10 } from "commander";
+import { resolve as resolve9 } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { loadConfig as loadConfig8 } from "@txfence/mcp";
+import {
+  executeIntent,
+  evaluateIntent,
+  validateIntentGraph,
+  formatExecutionFailureReason as formatExecutionFailureReason2,
+  bigintReplacer
+} from "@txfence/core";
+import { executeEvmAction as executeEvmAction2, simulateIntentOnFork } from "@txfence/evm";
+function reviveIntent(raw) {
+  const steps = raw["steps"].map((step) => {
+    const action = step["action"];
+    if (action["kind"] === "transfer") {
+      const token = action["token"];
+      if (typeof token["amount"] === "string") token["amount"] = BigInt(token["amount"]);
+    }
+    if (action["kind"] === "swap") {
+      const from = action["from"];
+      if (typeof from["amount"] === "string") from["amount"] = BigInt(from["amount"]);
+    }
+    if (action["kind"] === "contract_call" && action["value"] !== void 0) {
+      const value = action["value"];
+      if (typeof value["amount"] === "string") value["amount"] = BigInt(value["amount"]);
+    }
+    return step;
+  });
+  const intentPolicy = raw["intentPolicy"];
+  if (intentPolicy !== void 0) {
+    const reviveTokenAmount = (field) => {
+      const ta = intentPolicy[field];
+      if (ta !== void 0 && typeof ta["amount"] === "string") {
+        ta["amount"] = BigInt(ta["amount"]);
+      }
+    };
+    reviveTokenAmount("maxTotalGrossSpend");
+    reviveTokenAmount("maxNetSpend");
+    reviveTokenAmount("maxIntermediateExposure");
+  }
+  return {
+    id: raw["id"],
+    ...raw["label"] !== void 0 ? { label: raw["label"] } : {},
+    steps,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ...intentPolicy !== void 0 ? { intentPolicy } : {}
+  };
+}
+var validateCmd = new Command10("validate").description("Validate an intent file \u2014 check for cycles, missing dependencies, and policy violations").requiredOption("--config <path>", "path to txfence config").requiredOption("--intent <path>", "path to intent JSON file");
+validateCmd.action(async (opts) => {
+  try {
+    const config = await loadConfig8(resolve9(opts["config"]));
+    const intentRaw = JSON.parse(readFileSync2(resolve9(opts["intent"]), "utf-8"));
+    const intent = reviveIntent(intentRaw);
+    console.log("\n=== Intent Validation ===\n");
+    console.log(`Intent ID: ${intent.id}`);
+    console.log(`Steps:     ${intent.steps.length}`);
+    const graphResult = validateIntentGraph(intent);
+    if (!graphResult.valid) {
+      console.error(`
+[INVALID] Graph error: ${graphResult.detail}`);
+      console.error(`Reason: ${graphResult.reason}`);
+      process.exit(1);
+    }
+    console.log(`
+Graph:     VALID`);
+    console.log(`Execution plan: ${graphResult.executionPlan.join(" \u2192 ")}`);
+    const evalResult = evaluateIntent(intent, config.policy);
+    if (!evalResult.passed) {
+      console.error(`
+[REJECTED] Intent policy evaluation failed`);
+      console.error(`Reason: ${evalResult.rejectionReason}`);
+      if (evalResult.stepEvaluations.some((s) => !s.evaluation.passed)) {
+        console.error("\nFailed steps:");
+        for (const step of evalResult.stepEvaluations.filter((s) => !s.evaluation.passed)) {
+          console.error(`  ${step.stepId}: ${step.evaluation.rejectionReason}`);
+        }
+      }
+      process.exit(1);
+    }
+    console.log(`
+Policy:    PASSED`);
+    if (evalResult.intentPolicyEvaluation !== void 0) {
+      const pos = evalResult.intentPolicyEvaluation.positionAnalysis;
+      console.log(`
+Position analysis:`);
+      console.log(`  Single token:        ${pos.isSingleToken}`);
+      if (pos.dominantToken !== void 0) {
+        console.log(`  Token:               ${pos.dominantToken}`);
+      }
+      console.log(`  Total gross outflow: ${pos.totalGrossOutflow}`);
+      console.log(`  Max intermediate:    ${pos.maxIntermediateExposure}`);
+    }
+    console.log("\nIntent is valid and ready to execute.");
+    process.exit(0);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+var submitCmd = new Command10("submit").description("Execute an intent \u2014 runs all steps in dependency order").requiredOption("--config <path>", "path to txfence config").requiredOption("--intent <path>", "path to intent JSON file").option("--dry-run", "validate and evaluate without executing", false).option("--json", "output results as JSON");
+submitCmd.action(async (opts) => {
+  try {
+    const config = await loadConfig8(resolve9(opts["config"]));
+    const intentRaw = JSON.parse(readFileSync2(resolve9(opts["intent"]), "utf-8"));
+    const intent = reviveIntent(intentRaw);
+    const isDryRun = opts["dryRun"] === true;
+    const isJson = opts["json"] === true;
+    console.log(`
+=== Intent Submit${isDryRun ? " (dry run)" : ""} ===
+`);
+    console.log(`Intent ID: ${intent.id}`);
+    if (intent.label !== void 0) console.log(`Label:     ${intent.label}`);
+    console.log(`Steps:     ${intent.steps.length}`);
+    if (isDryRun) {
+      const evalResult = evaluateIntent(intent, config.policy);
+      if (isJson) {
+        console.log(JSON.stringify(evalResult, bigintReplacer, 2));
+      } else {
+        console.log(`
+Evaluation: ${evalResult.passed ? "PASSED" : "REJECTED"}`);
+        if (!evalResult.passed) {
+          console.error(`Reason: ${evalResult.rejectionReason}`);
+        }
+        console.log(`Execution plan: ${evalResult.executionPlan.join(" \u2192 ")}`);
+      }
+      process.exit(evalResult.passed ? 0 : 1);
+    }
+    const executor = config.signer !== void 0 ? (action, chainId, rpcUrl, evaluation, simulation) => executeEvmAction2(action, chainId, rpcUrl, config.signer, evaluation, simulation) : void 0;
+    const result = await executeIntent(intent, config.policy, {
+      adapters: config.adapters,
+      rpcUrls: config.rpcUrls,
+      ...executor !== void 0 ? { executor } : {}
+    });
+    if (isJson) {
+      console.log(JSON.stringify(result, bigintReplacer, 2));
+    } else {
+      console.log(`
+Status:    ${result.status.toUpperCase()}`);
+      console.log(`Duration:  ${result.durationMs}ms`);
+      console.log("");
+      if (result.completedStepIds.length > 0) {
+        console.log(`Completed (${result.completedStepIds.length}):`);
+        for (const stepId of result.completedStepIds) {
+          const receipt = result.receipts[stepId];
+          console.log(`  + ${stepId}: ${receipt?.txHash ?? "no receipt"}`);
+        }
+      }
+      if (result.failedStepIds.length > 0) {
+        console.log(`
+Failed (${result.failedStepIds.length}):`);
+        for (const stepId of result.failedStepIds) {
+          const stepResult = result.stepResults.find((r) => r.stepId === stepId);
+          const reason = stepResult?.status === "failed" ? formatExecutionFailureReason2(stepResult.reason) : "unknown";
+          console.log(`  x ${stepId}: ${reason}`);
+        }
+      }
+      if (result.skippedStepIds.length > 0) {
+        console.log(`
+Skipped (${result.skippedStepIds.length}):`);
+        for (const stepId of result.skippedStepIds) {
+          console.log(`  - ${stepId}`);
+        }
+      }
+      console.log("");
+      const pos = result.positionAnalysis;
+      if (pos.totalGrossOutflow > 0n) {
+        console.log(`Total gross outflow: ${pos.totalGrossOutflow}`);
+      }
+    }
+    process.exit(
+      result.status === "completed" ? 0 : result.status === "partial" ? 2 : 1
+    );
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+var forkSimulateCmd = new Command10("fork-simulate").description("Simulate a multi-step intent on a forked chain state \u2014 shows final position without executing").requiredOption("--config <path>", "path to txfence config").requiredOption("--intent <path>", "path to intent JSON file").requiredOption("--from <address>", "agent address for all simulated transactions").requiredOption("--chain <chain>", "chain to fork (e.g. ethereum, base, arbitrum)").option("--block <number>", "block number to fork at (default: latest)").option("--json", "output results as JSON");
+forkSimulateCmd.action(async (opts) => {
+  try {
+    const config = await loadConfig8(resolve9(opts.config));
+    const intentRaw = JSON.parse(readFileSync2(resolve9(opts.intent), "utf-8"));
+    const intent = reviveIntent(intentRaw);
+    const tenderlyAccessKey = process.env.TENDERLY_ACCESS_KEY;
+    const tenderlyAccountSlug = process.env.TENDERLY_ACCOUNT_SLUG;
+    const tenderlyProjectSlug = process.env.TENDERLY_PROJECT_SLUG;
+    if (!tenderlyAccessKey || !tenderlyAccountSlug || !tenderlyProjectSlug) {
+      console.error(
+        "Fork simulation requires Tenderly credentials.\nSet these environment variables:\n  TENDERLY_ACCESS_KEY\n  TENDERLY_ACCOUNT_SLUG\n  TENDERLY_PROJECT_SLUG"
+      );
+      process.exit(1);
+    }
+    const forkConfig = {
+      provider: "tenderly",
+      tenderlyConfig: {
+        accessKey: tenderlyAccessKey,
+        accountSlug: tenderlyAccountSlug,
+        projectSlug: tenderlyProjectSlug
+      },
+      fromAddress: opts.from,
+      ...opts.block !== void 0 ? { blockNumber: parseInt(opts.block, 10) } : {}
+    };
+    const rpcUrl = config.rpcUrls?.[opts.chain] ?? process.env.ETHEREUM_RPC_URL;
+    if (!rpcUrl) {
+      console.error(`No RPC URL configured for chain ${opts.chain}`);
+      process.exit(1);
+    }
+    console.log(`
+=== Fork Simulation ===
+`);
+    console.log(`Intent:  ${intent.id}${intent.label ? ` (${intent.label})` : ""}`);
+    console.log(`Chain:   ${opts.chain}`);
+    console.log(`From:    ${opts.from}`);
+    console.log(`Steps:   ${intent.steps.length}`);
+    console.log(`
+Creating fork and simulating...`);
+    const result = await simulateIntentOnFork(
+      intent,
+      forkConfig,
+      opts.chain,
+      rpcUrl
+    );
+    if (opts.json) {
+      console.log(JSON.stringify(result, bigintReplacer, 2));
+      process.exit(result.wouldAllSucceed ? 0 : 1);
+      return;
+    }
+    console.log(`
+=== Results ===
+`);
+    console.log(`Forked at block: ${result.forkedAtBlock}`);
+    console.log(`Would all succeed: ${result.wouldAllSucceed ? "YES" : "NO"}`);
+    if (result.failingStepId !== void 0) {
+      console.log(`Failing step:      ${result.failingStepId}`);
+    }
+    console.log("");
+    console.log("Step results:");
+    for (const step of result.steps) {
+      const status = step.wouldRevert ? "\u2717 REVERT" : "\u2713 SUCCESS";
+      console.log(`  ${status}  ${step.stepId}`);
+      if (step.wouldRevert && step.revertReason !== void 0) {
+        console.log(`         Reason: ${step.revertReason}`);
+      }
+      if (step.stateChanges.length > 0) {
+        console.log(`         State changes: ${step.stateChanges.length}`);
+        for (const sc of step.stateChanges) {
+          const sign = sc.delta >= 0n ? "+" : "";
+          console.log(`           ${sc.address.slice(0, 10)}... ${sign}${sc.delta}`);
+        }
+      }
+    }
+    if (result.finalPosition.length > 0) {
+      console.log("\nFinal position delta:");
+      for (const pos of result.finalPosition) {
+        const sign = pos.amount >= 0n ? "+" : "";
+        console.log(`  ${pos.token} on ${pos.chain}: ${sign}${pos.amount}`);
+      }
+    } else {
+      console.log("\nFinal position: no changes detected");
+    }
+    console.log("");
+    process.exit(result.wouldAllSucceed ? 0 : 1);
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});
+function makeIntentCommand() {
+  const cmd = new Command10("intent").description("Intent execution commands");
+  cmd.addCommand(validateCmd);
+  cmd.addCommand(submitCmd);
+  cmd.addCommand(forkSimulateCmd);
+  return cmd;
+}
+
+// src/commands/replay.ts
+import { Command as Command11 } from "commander";
+import { resolve as resolve10 } from "path";
+import { loadConfig as loadConfig9 } from "@txfence/mcp";
+import { replayAuditLog, bigintReplacer as bigintReplacer2 } from "@txfence/core";
+import { createFileAuditLog } from "@txfence/audit";
+function makeReplayCommand() {
+  const cmd = new Command11("replay").description("Replay historical audit log entries against a new policy \u2014 shows what would have changed").requiredOption("--audit-log <path>", "path to the audit log JSONL file").requiredOption("--config <path>", "path to the proposed txfence config to test against").option("--from <timestamp>", "replay entries from this timestamp (ms since epoch)").option("--to <timestamp>", "replay entries up to this timestamp (ms since epoch)").option("--kind <kind>", "filter by action kind: transfer, swap, or contract_call").option("--chain <chain>", "filter by chain").option("--only-changed", "only show entries where outcome changed", false).option("--json", "output results as JSON");
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig9(resolve10(opts["config"]));
+      const auditLog = createFileAuditLog(resolve10(opts["auditLog"]));
+      const fromOpt = opts["from"];
+      const toOpt = opts["to"];
+      const kindOpt = opts["kind"];
+      const chainOpt = opts["chain"];
+      const onlyChanged = opts["onlyChanged"] === true;
+      const replayOptions = {
+        ...fromOpt !== void 0 ? { from: parseInt(fromOpt, 10) } : {},
+        ...toOpt !== void 0 ? { to: parseInt(toOpt, 10) } : {},
+        ...kindOpt !== void 0 ? { actionKind: kindOpt } : {},
+        ...chainOpt !== void 0 ? { chain: chainOpt } : {},
+        ...onlyChanged ? { onlyChanged: true } : {}
+      };
+      console.log("\n=== Policy Replay ===\n");
+      console.log(`Audit log: ${opts["auditLog"]}`);
+      console.log(`Policy:    ${opts["config"]}`);
+      if (fromOpt !== void 0) console.log(`From:      ${new Date(parseInt(fromOpt, 10)).toISOString()}`);
+      if (toOpt !== void 0) console.log(`To:        ${new Date(parseInt(toOpt, 10)).toISOString()}`);
+      console.log("\nReplaying...");
+      const result = await replayAuditLog(auditLog, config.policy, replayOptions);
+      if (opts["json"] === true) {
+        console.log(JSON.stringify(result, bigintReplacer2, 2));
+        process.exit(result.summary.newlyRejected > 0 ? 1 : 0);
+        return;
+      }
+      console.log("\n=== Summary ===\n");
+      console.log(`Total entries:             ${result.summary.total}`);
+      console.log(`Unchanged:                 ${result.summary.unchanged}`);
+      console.log(`Changed:                   ${result.summary.changed}`);
+      console.log(`  Newly allowed:           ${result.summary.newlyAllowed}`);
+      console.log(`  Newly rejected:          ${result.summary.newlyRejected}`);
+      console.log(`  Rejection reason changed: ${result.summary.rejectionReasonChanged}`);
+      if (result.summary.skipped > 0) {
+        console.log(`Skipped (no eval data):    ${result.summary.skipped}`);
+      }
+      if (result.summary.changed === 0) {
+        console.log("\nNo changes \u2014 this policy would have produced identical outcomes.");
+        process.exit(0);
+      }
+      console.log("\n=== Changed Entries ===\n");
+      const changedEntries = result.entries.filter((e) => e.changed);
+      for (const entry of changedEntries) {
+        const direction = entry.direction?.toUpperCase().replace(/_/g, " ") ?? "CHANGED";
+        const ts = new Date(entry.timestamp).toISOString();
+        const act = entry.action;
+        const actionDesc = act.kind === "transfer" ? `transfer ${act.token.amount} ${act.token.token} on ${act.chain}` : act.kind === "swap" ? `swap ${act.from.amount} ${act.from.token} on ${act.chain}` : `contract_call on ${act.chain}`;
+        console.log(`[${direction}] ${ts}`);
+        console.log(`  ${actionDesc}`);
+        console.log(`  Original: ${entry.originalEvaluation.passed ? "PASSED" : `REJECTED (${entry.originalEvaluation.rejectionReason})`}`);
+        console.log(`  Replay:   ${entry.replayEvaluation.passed ? "PASSED" : `REJECTED (${entry.replayEvaluation.rejectionReason})`}`);
+        if (entry.changedChecks.length > 0) {
+          console.log(`  Changed checks: ${entry.changedChecks.map((c) => c.checkName).join(", ")}`);
+        }
+        console.log();
+      }
+      process.exit(result.summary.newlyRejected > 0 ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+
+// src/commands/verify.ts
+import { Command as Command12 } from "commander";
+import { resolve as resolve11 } from "path";
+import { loadConfig as loadConfig10 } from "@txfence/mcp";
+import { verify } from "@txfence/verify";
+import { bigintReplacer as bigintReplacer3 } from "@txfence/core";
+function makeVerifyCommand() {
+  const cmd = new Command12("verify").description("Verify policy invariants using bounded model checking");
+  const rollingWindowCmd = new Command12("rolling-window").description(
+    "Check whether N agents sharing a rolling window cap can collectively exceed it. Generates a concrete counterexample if the invariant is violated."
+  ).requiredOption("--config <path>", "path to txfence config").requiredOption("--agents <n>", "number of concurrent agents to check").requiredOption("--transactions <n>", "max transactions per agent to check").requiredOption("--cap <amount>", "rolling window cap amount (integer)").requiredOption("--window <ms>", "rolling window duration in milliseconds").requiredOption("--token <symbol>", "token symbol (e.g. USDC)").option("--json", "output results as JSON");
+  rollingWindowCmd.action(async (opts) => {
+    try {
+      const config = await loadConfig10(resolve11(opts["config"]));
+      const maxSpendPerTx = config.policy.maxSpendPerTx.amount;
+      const property = {
+        kind: "rolling_window_saturation",
+        agentCount: parseInt(opts["agents"], 10),
+        transactionsPerAgent: parseInt(opts["transactions"], 10),
+        windowMs: parseInt(opts["window"], 10),
+        capAmount: BigInt(opts["cap"]),
+        token: opts["token"],
+        maxSpendPerTx
+      };
+      console.log("\n=== Rolling Window Saturation Check ===\n");
+      console.log(`Agents:           ${property.agentCount}`);
+      console.log(`Tx per agent:     ${property.transactionsPerAgent}`);
+      console.log(`Window:           ${property.windowMs}ms`);
+      console.log(`Cap:              ${property.capAmount} ${property.token}`);
+      console.log(`Max spend per tx: ${property.maxSpendPerTx} ${property.token}`);
+      console.log("\nVerifying...");
+      const result = verify(property);
+      if (opts["json"]) {
+        console.log(JSON.stringify(result, bigintReplacer3, 2));
+        process.exit(result.status === "violated" ? 1 : 0);
+      }
+      printResult(result);
+      process.exit(result.status === "violated" ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  const absoluteCapCmd = new Command12("absolute-cap").description(
+    "Check whether N agents can collectively reach or exceed the absolute cap. Produces a minimal counterexample showing how few transactions are needed."
+  ).requiredOption("--config <path>", "path to txfence config").requiredOption("--agents <n>", "number of concurrent agents to check").requiredOption("--transactions <n>", "max transactions per agent to check").requiredOption("--cap <amount>", "absolute cap amount (integer)").requiredOption("--token <symbol>", "token symbol (e.g. USDC)").option("--json", "output results as JSON");
+  absoluteCapCmd.action(async (opts) => {
+    try {
+      const config = await loadConfig10(resolve11(opts["config"]));
+      const maxSpendPerTx = config.policy.maxSpendPerTx.amount;
+      const property = {
+        kind: "absolute_cap_reachability",
+        agentCount: parseInt(opts["agents"], 10),
+        transactionsPerAgent: parseInt(opts["transactions"], 10),
+        capAmount: BigInt(opts["cap"]),
+        token: opts["token"],
+        maxSpendPerTx
+      };
+      console.log("\n=== Absolute Cap Reachability Check ===\n");
+      console.log(`Agents:           ${property.agentCount}`);
+      console.log(`Tx per agent:     ${property.transactionsPerAgent}`);
+      console.log(`Cap:              ${property.capAmount} ${property.token}`);
+      console.log(`Max spend per tx: ${property.maxSpendPerTx} ${property.token}`);
+      console.log("\nVerifying...");
+      const result = verify(property);
+      if (opts["json"]) {
+        console.log(JSON.stringify(result, bigintReplacer3, 2));
+        process.exit(result.status === "violated" ? 1 : 0);
+      }
+      printResult(result);
+      process.exit(result.status === "violated" ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  const policyContainsCmd = new Command12("policy-contains").description(
+    "Check whether every action allowed by the inner policy is also allowed by the outer policy. Finds concrete actions that inner allows but outer rejects."
+  ).requiredOption("--inner <path>", "path to the inner (narrower) txfence config").requiredOption("--outer <path>", "path to the outer (wider) txfence config").option("--json", "output results as JSON");
+  policyContainsCmd.action(async (opts) => {
+    try {
+      const innerConfig = await loadConfig10(resolve11(opts["inner"]));
+      const outerConfig = await loadConfig10(resolve11(opts["outer"]));
+      const property = {
+        kind: "policy_containment",
+        innerPolicy: innerConfig.policy,
+        outerPolicy: outerConfig.policy
+      };
+      console.log("\n=== Policy Containment Check ===\n");
+      console.log(`Inner policy: ${opts["inner"]}`);
+      console.log(`Outer policy: ${opts["outer"]}`);
+      console.log("\nVerifying...");
+      const result = verify(property);
+      if (opts["json"]) {
+        console.log(JSON.stringify(result, bigintReplacer3, 2));
+        process.exit(result.status === "violated" ? 1 : 0);
+      }
+      printResult(result);
+      process.exit(result.status === "violated" ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  cmd.addCommand(rollingWindowCmd);
+  cmd.addCommand(absoluteCapCmd);
+  cmd.addCommand(policyContainsCmd);
+  return cmd;
+}
+function printResult(result) {
+  console.log("");
+  if (result.status === "holds") {
+    console.log(`\u2713 HOLDS \u2014 ${result.property}`);
+    console.log(`  Checked: ${result.scenariosChecked} scenario(s)`);
+    console.log(
+      `  Bound:   ${result.checkedBound.agentCount} agents, ${result.checkedBound.transactionsPerAgent} tx/agent` + (result.checkedBound.windowMs !== void 0 ? `, ${result.checkedBound.windowMs}ms window` : "")
+    );
+    console.log(`  Time:    ${result.durationMs}ms`);
+    console.log("");
+    console.log("The invariant holds within the checked bound.");
+    console.log("Increase --agents and --transactions to check larger bounds.");
+  } else if (result.status === "violated") {
+    console.log(`\u2717 VIOLATED \u2014 ${result.property}`);
+    console.log(`  Time: ${result.durationMs}ms`);
+    console.log("");
+    console.log("Counterexample:");
+    console.log(`  ${result.counterExample.description}`);
+    console.log("");
+    console.log(`  Violated at transaction: ${result.counterExample.violatedAt}`);
+    console.log(`  Violated amount:         ${result.counterExample.violatedAmount}`);
+    console.log(`  Cap limit:               ${result.counterExample.capLimit}`);
+    console.log("");
+    console.log(
+      `  Transactions in counterexample: ${result.counterExample.transactions.length}`
+    );
+    const preview = result.counterExample.transactions.slice(0, 5);
+    for (const tx of preview) {
+      console.log(`    ${tx.agentId} \u2014 ${tx.amount} at t=${tx.timestamp}ms`);
+    }
+    if (result.counterExample.transactions.length > 5) {
+      console.log(
+        `    ... and ${result.counterExample.transactions.length - 5} more`
+      );
+    }
+  }
+}
+
+// src/commands/stress-test.ts
+import { Command as Command13 } from "commander";
+import { resolve as resolve12 } from "path";
+import { loadConfig as loadConfig11 } from "@txfence/mcp";
+import { stressTest, DEFAULT_VECTORS } from "@txfence/verify";
+import { bigintReplacer as bigintReplacer4 } from "@txfence/core";
+function makeStressTestCommand() {
+  const cmd = new Command13("stress-test").description(
+    "Run thousands of adversarial scenarios against a policy configuration. Produces a risk report showing which attack vectors your policy survives."
+  ).requiredOption("--config <path>", "path to txfence config").option("--agents <n>", "number of concurrent agents to simulate", "10").option("--transactions <n>", "transactions per scenario", "20").option("--jitter <ms>", "max timing jitter in milliseconds", "50").option(
+    "--vectors <list>",
+    "comma-separated attack vectors to test: rapid_fire,coordinated_drain,rpc_failure,stale_simulation,cap_boundary,approval_flood"
+  ).option("--timeout <ms>", "per-scenario timeout in milliseconds", "5000").option("--json", "output results as JSON").option("--only-failures", "only show failed scenarios in output");
+  cmd.action(async (opts) => {
+    try {
+      const config = await loadConfig11(resolve12(opts.config));
+      const vectors = opts.vectors !== void 0 ? opts.vectors.split(",").map((v) => v.trim()) : void 0;
+      const stressConfig = {
+        agentCount: parseInt(opts.agents, 10),
+        transactionsPerScenario: parseInt(opts.transactions, 10),
+        timingJitterMs: parseInt(opts.jitter, 10),
+        timeoutMs: parseInt(opts.timeout, 10),
+        ...vectors !== void 0 ? { vectors } : {}
+      };
+      if (opts.json !== true) {
+        console.log("\n=== Policy Stress Test ===\n");
+        console.log(`Config:       ${opts.config}`);
+        console.log(`Agents:       ${stressConfig.agentCount}`);
+        console.log(`Tx/scenario:  ${stressConfig.transactionsPerScenario}`);
+        console.log(`Timing jitter: ${stressConfig.timingJitterMs}ms`);
+        console.log(`Vectors:      ${(vectors ?? DEFAULT_VECTORS).join(", ")}`);
+        console.log("\nRunning adversarial scenarios...");
+      }
+      const report = await stressTest(config.policy, stressConfig);
+      if (opts.json === true) {
+        console.log(JSON.stringify(report, bigintReplacer4, 2));
+        process.exit(report.failed > 0 ? 1 : 0);
+      }
+      printRiskReport(report, opts.onlyFailures === true);
+      process.exit(report.failed > 0 ? 1 : 0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  return cmd;
+}
+function printRiskReport(report, onlyFailures) {
+  console.log("\n=== Risk Report ===\n");
+  const pct = (report.survivalRate * 100).toFixed(1);
+  const statusIcon = report.failed === 0 ? "\u2713" : "\u2717";
+  console.log(
+    `${statusIcon} Survival rate: ${pct}% (${report.survived}/${report.totalScenarios} scenarios)`
+  );
+  console.log(`  Duration:     ${report.durationMs}ms`);
+  console.log("");
+  console.log("Results by attack vector:");
+  for (const [vector, stats] of Object.entries(report.byVector)) {
+    const failPct = stats.total > 0 ? (stats.failed / stats.total * 100).toFixed(0) : "0";
+    const icon = stats.failed === 0 ? "\u2713" : "\u2717";
+    console.log(
+      `  ${icon} ${vector.padEnd(20)} ${stats.failed}/${stats.total} failed (${failPct}%)`
+    );
+  }
+  console.log("");
+  if (report.failed > 0) {
+    console.log("Failures by severity:");
+    const severityOrder = ["critical", "high", "medium", "low"];
+    for (const severity of severityOrder) {
+      const count = report.bySeverity[severity] ?? 0;
+      if (count > 0) {
+        const icon = severity === "critical" || severity === "high" ? "\u26A0" : "!";
+        console.log(`  ${icon} ${severity.padEnd(10)} ${count} scenario(s)`);
+      }
+    }
+    console.log("");
+  }
+  if (report.failed > 0) {
+    console.log(`Failed scenarios (${report.failed}):`);
+    for (const scenario of report.failedScenarios) {
+      console.log(
+        `
+  [${scenario.severity.toUpperCase()}] ${scenario.vector} \u2014 ${scenario.description}`
+      );
+      console.log(`    Outcome: ${scenario.outcome}`);
+      console.log(`    Details: ${scenario.details}`);
+      console.log(`    Time:    ${scenario.durationMs}ms`);
+    }
+    console.log("");
+  } else if (!onlyFailures) {
+    console.log("All scenarios passed \u2014 no failures detected.");
+    console.log("");
+  }
+  console.log("Recommendation:");
+  const lines = report.recommendation.split("\n\n");
+  for (const line of lines) {
+    console.log(`  ${line}`);
+    if (lines.length > 1) console.log("");
+  }
+}
+
+// src/commands/provenance.ts
+import { Command as Command14 } from "commander";
+import { resolve as resolve13 } from "path";
+import { createFileProvenanceChain } from "@txfence/provenance";
+function makeProvenanceCommand() {
+  const cmd = new Command14("provenance").description(
+    "Provenance chain commands \u2014 verify tamper-evident audit trails"
+  );
+  const verifyCmd = new Command14("verify").description(
+    "Verify a provenance chain file \u2014 checks hash chain integrity and detects tampering"
+  ).requiredOption("--chain <path>", "path to provenance chain JSONL file").option("--json", "output results as JSON");
+  verifyCmd.action(async (opts) => {
+    try {
+      const chain = createFileProvenanceChain(resolve13(opts.chain));
+      const result = await chain.verify();
+      if (opts.json === true) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(result.valid ? 0 : 1);
+      }
+      console.log("\n=== Provenance Chain Verification ===\n");
+      console.log(`File:         ${opts.chain}`);
+      console.log(`Records:      ${result.entryCount}`);
+      console.log(`Valid:        ${result.valid ? "YES \u2713" : "NO \u2717"}`);
+      console.log(`Merkle root:  ${result.merkleRoot.slice(0, 16)}...`);
+      console.log(`Verified at:  ${new Date(result.verifiedAt).toISOString()}`);
+      if (result.entryCount > 0) {
+        console.log(`First hash:   ${result.firstHash.slice(0, 16)}...`);
+        console.log(`Last hash:    ${result.lastHash.slice(0, 16)}...`);
+      }
+      if (result.violations.length > 0) {
+        console.log(`
+Violations (${result.violations.length}):`);
+        for (const v of result.violations) {
+          console.log(`  [${v.violation.toUpperCase()}] ${v.entryId}`);
+          console.log(`    ${v.details}`);
+        }
+        console.log(
+          "\nWARNING: This chain has been tampered with or corrupted."
+        );
+        console.log("Do not rely on this chain for compliance purposes.");
+      } else if (result.entryCount > 0) {
+        console.log("\nAll records verified. Chain integrity confirmed.");
+      } else {
+        console.log("\nEmpty chain.");
+      }
+      process.exit(result.valid ? 0 : 1);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  const proofCmd = new Command14("proof").description("Generate a Merkle proof for a specific provenance record").requiredOption("--chain <path>", "path to provenance chain JSONL file").requiredOption("--hash <entryHash>", "entry hash to generate proof for").option("--json", "output proof as JSON");
+  proofCmd.action(async (opts) => {
+    try {
+      const chain = createFileProvenanceChain(resolve13(opts.chain));
+      const proof = await chain.generateProof(opts.hash);
+      if (proof === null) {
+        console.error(`Entry hash not found in chain: ${opts.hash}`);
+        process.exit(1);
+      }
+      if (opts.json === true) {
+        console.log(JSON.stringify(proof, null, 2));
+        process.exit(0);
+      }
+      console.log("\n=== Merkle Proof ===\n");
+      console.log(`Entry hash:   ${proof.entryHash}`);
+      console.log(`Merkle root:  ${proof.root}`);
+      console.log(`Leaf index:   ${proof.leafIndex}`);
+      console.log(`Proof depth:  ${proof.siblings.length} sibling(s)`);
+      console.log("\nSiblings:");
+      for (let i = 0; i < proof.siblings.length; i++) {
+        const s = proof.siblings[i];
+        console.log(`  [${i}] ${s.position.padEnd(5)} ${s.hash.slice(0, 16)}...`);
+      }
+      console.log("\nTo verify this proof:");
+      console.log(`  txfence provenance verify --chain ${opts.chain}`);
+      console.log("\nProof JSON (for external verification):");
+      console.log(JSON.stringify(proof));
+      process.exit(0);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(1);
+    }
+  });
+  cmd.addCommand(verifyCmd);
+  cmd.addCommand(proofCmd);
+  return cmd;
+}
+
+// src/index.ts
+var program = new Command15().name("txfence").description("txfence CLI \u2014 policy checking, simulation, and execution for on-chain agents").version("0.0.1");
+program.addCommand(makeSimulateCommand());
+program.addCommand(makeCheckPolicyCommand());
+program.addCommand(makeSubmitCommand());
+program.addCommand(makeReceiptCommand());
+program.addCommand(makeInitCommand());
+program.addCommand(makeDiffCommand());
+program.addCommand(makeDryRunCommand());
+program.addCommand(makePolicySnapshotCommand());
+program.addCommand(makeIntentCommand());
+program.addCommand(makeReplayCommand());
+program.addCommand(makeVerifyCommand());
+program.addCommand(makeStressTestCommand());
+program.addCommand(makeProvenanceCommand());
+program.parse(process.argv);