@bloxwap/agent-cli 0.0.0-stage → 0.4.0

package/dist/cli.js

@@ -0,0 +1,2345 @@
+#!/usr/bin/env node
+import {
+  AgentCliError,
+  PERPS_USDC,
+  PaperStore,
+  RelayClient,
+  Runner,
+  abandonDeposit,
+  accountEquity,
+  accrueFunding,
+  activeRunner,
+  applyPolicy,
+  assertApprovedNetwork,
+  assertCanTrade,
+  assertLiveMode,
+  assertSafeInput,
+  atomicWrite,
+  auditStoreFor,
+  checkRisk,
+  configPath,
+  copyAgentFields,
+  createAgent,
+  createClients,
+  detachRunner,
+  dispatch,
+  eventTypes,
+  events,
+  exchangeAction,
+  expiryWarnings,
+  followEvents,
+  formatUsdc,
+  hlEndpoint,
+  hlInfo,
+  jsonRequest,
+  levels,
+  liquidate,
+  liquidationPx,
+  loadConfig,
+  mapHyperliquidError,
+  matchOrders,
+  migrate,
+  newCloid,
+  nextNonce,
+  normalizeError,
+  openSigner,
+  paperAccountState,
+  paperData,
+  paperDataNetwork,
+  paperDir,
+  paperEvents,
+  paperOpenOrders,
+  parseQuote,
+  parseUsdc,
+  pollDeposits,
+  prepareEoaAgent,
+  privyClient,
+  readAudit,
+  readDeposits,
+  readEvents,
+  readStoredConfig,
+  redact,
+  register,
+  requiredDailyLoss,
+  resolveMode,
+  rolloverDay,
+  roundPrice,
+  roundSize,
+  routeToRunner,
+  rpcServer,
+  runnerPidPath,
+  runningInfo,
+  saveConfig,
+  servicesForMode,
+  setActiveRunner,
+  setRouting,
+  stateDir,
+  updateConfig,
+  updateDeposits,
+  verifyAudit,
+  withTradeLock
+} from "./chunk-R7P7UMOD.js";
+
+// src/commands/config.ts
+import { z } from "zod";
+register("config", {
+  description: "Get, set or validate local configuration",
+  schema: z.object({
+    args: z.array(z.string()).default([]),
+    yes: z.boolean().default(false)
+  }),
+  execute: async ({ args, yes }, context) => {
+    const [action = "get", key, value] = args;
+    const config = await loadConfig(context.configPath, {});
+    if (action === "validate") return { valid: true, version: config.version };
+    if (action === "get")
+      return key ? key.split(".").reduce(
+        (v, k) => v?.[k],
+        config
+      ) ?? null : config;
+    if (action !== "set" || !key || value === void 0)
+      throw new AgentCliError("CONFIG_INVALID", "Use config set key value");
+    let parsed;
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      parsed = value;
+    }
+    if (key === "network" && config.approvedNetwork && parsed !== config.approvedNetwork)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Network is pinned to the agent approval; use a separate config for another network"
+      );
+    if (key === "mode" && parsed === "live" && !yes && config.mode !== "live")
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Switching to live mode requires explicit confirmation; re-run with --yes"
+      );
+    const updated = structuredClone(config);
+    const parts = key.split(".");
+    let cursor = updated;
+    for (const part of parts.slice(0, -1)) {
+      if (!Object.hasOwn(cursor, part) || !cursor[part] || typeof cursor[part] !== "object")
+        throw new AgentCliError("CONFIG_INVALID", "Unknown config key");
+      cursor = cursor[part];
+    }
+    if (["__proto__", "constructor", "prototype"].some((p) => parts.includes(p)))
+      throw new AgentCliError("CONFIG_INVALID", "Invalid key");
+    cursor[parts.at(-1)] = parsed;
+    const validated = migrate(updated);
+    await saveConfig(validated, context.configPath);
+    return validated;
+  }
+});
+
+// src/commands/init.ts
+import { z as z2 } from "zod";
+
+// src/funding/qr.ts
+import QRCode from "qrcode";
+import { writeFile } from "fs/promises";
+async function renderQr(value, options = {}) {
+  if (options.enabled === false) return { qrAscii: null, qrPath: null };
+  const qrAscii = await QRCode.toString(value, {
+    type: "terminal",
+    small: true
+  });
+  (options.stderr ?? ((value2) => process.stderr.write(value2)))(qrAscii + "\n");
+  if (options.path) {
+    if (options.path.endsWith(".svg"))
+      await writeFile(
+        options.path,
+        await QRCode.toString(value, { type: "svg" }),
+        { mode: 384 }
+      );
+    else
+      await writeFile(
+        options.path,
+        await QRCode.toBuffer(value, { type: "png" }),
+        { mode: 384 }
+      );
+  }
+  return { qrAscii, qrPath: options.path ?? null };
+}
+
+// src/commands/init.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join } from "path";
+
+// src/wallet/approval.ts
+import { readFile } from "fs/promises";
+import { ApproveAgentTypes } from "@bloxwap/hyperliquid/api/exchange/approveAgent";
+import { ApproveBuilderFeeTypes } from "@bloxwap/hyperliquid/api/exchange/approveBuilderFee";
+var APPROVAL_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+function approval(network, type, fields, nonce = Date.now()) {
+  const types = type === "approveAgent" ? ApproveAgentTypes : ApproveBuilderFeeTypes;
+  const action = {
+    type,
+    signatureChainId: "0xa4b1",
+    hyperliquidChain: network === "mainnet" ? "Mainnet" : "Testnet",
+    ...fields,
+    nonce
+  };
+  const { type: _type, signatureChainId: _chain, ...message } = action;
+  void _type;
+  void _chain;
+  return {
+    action,
+    typedData: {
+      domain: {
+        name: "HyperliquidSignTransaction",
+        version: "1",
+        chainId: 42161,
+        verifyingContract: "0x" + "0".repeat(40)
+      },
+      types,
+      primaryType: Object.keys(types)[0],
+      message
+    }
+  };
+}
+async function submitApproval(network, pending, signature) {
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature))
+    throw new AgentCliError("CONFIG_INVALID", "Expected 65-byte signature");
+  const recovery = parseInt(signature.slice(-2), 16);
+  const v = recovery < 27 ? recovery + 27 : recovery;
+  if (v !== 27 && v !== 28)
+    throw new AgentCliError("CONFIG_INVALID", "Invalid signature recovery");
+  const response = await jsonRequest(`${hlEndpoint(network)}/exchange`, {
+    action: pending.action,
+    nonce: pending.action.nonce,
+    signature: {
+      r: signature.slice(0, 66),
+      s: "0x" + signature.slice(66, 130),
+      v
+    }
+  });
+  if (response.status !== "ok") {
+    const actionType = String(pending.action.type ?? "approval");
+    const rejection = typeof response.response === "string" ? response.response : JSON.stringify(response.response) ?? "Unknown rejection";
+    const nonceRejected = /nonce/i.test(rejection);
+    throw new AgentCliError(
+      "UPSTREAM_ERROR",
+      `${actionType} failed: ${rejection}`,
+      { hyperliquidResponse: response, nonceRejected },
+      false
+    );
+  }
+  return response;
+}
+function isFreshApproval(createdAt, now = Date.now()) {
+  return typeof createdAt === "number" && now >= createdAt && now - createdAt < APPROVAL_MAX_AGE_MS;
+}
+async function resolvePendingApproval(path, create, now = Date.now()) {
+  try {
+    const stored = JSON.parse(await readFile(path, "utf8"));
+    const approval2 = stored.approval?.action ? stored.approval : stored.action ? stored : void 0;
+    if (approval2?.action && isFreshApproval(stored.createdAt, now))
+      return {
+        approval: approval2,
+        createdAt: stored.createdAt,
+        expiresAt: stored.expiresAt ?? stored.createdAt + APPROVAL_MAX_AGE_MS
+      };
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const pending = {
+    approval: await create(),
+    createdAt: now,
+    expiresAt: now + APPROVAL_MAX_AGE_MS
+  };
+  await atomicWrite(path, JSON.stringify(pending));
+  return pending;
+}
+async function submitFreshApproval(network, path, pending, signature, refresh) {
+  if (!isFreshApproval(pending.createdAt)) {
+    const next = await resolvePendingApproval(path, refresh, Date.now());
+    throw new AgentCliError(
+      "CONFIG_INVALID",
+      "Approval payload expired; sign the regenerated payload",
+      { expiresAt: next.expiresAt, approval: next.approval }
+    );
+  }
+  try {
+    return await submitApproval(network, pending.approval, signature);
+  } catch (error) {
+    if (error instanceof AgentCliError && error.details?.nonceRejected) {
+      const next = await resolvePendingApproval(path, refresh, Date.now());
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Approval nonce was rejected; sign the regenerated payload",
+        { expiresAt: next.expiresAt, approval: next.approval }
+      );
+    }
+    throw error;
+  }
+}
+var rejectMasterKey = assertSafeInput;
+async function newApproval(config, type, fields) {
+  if (!config.masterAddress)
+    throw new AgentCliError("CONFIG_INVALID", "Master address required");
+  return approval(
+    config.network,
+    type,
+    fields,
+    await nextNonce(config.masterAddress)
+  );
+}
+
+// src/core/referral.ts
+async function ensureReferral(config) {
+  if (!config.masterAddress)
+    throw new AgentCliError("CONFIG_INVALID", "Master address required");
+  const referral = await hlInfo(config.network, "referral", { user: config.masterAddress });
+  if (referral.referredBy)
+    return {
+      referralCode: referral.referredBy.code,
+      referralApplied: true
+    };
+  const signer = await openSigner(config);
+  const clients = createClients(
+    config.network,
+    signer,
+    () => nextNonce(signer.address)
+  );
+  await clients.exchange.setReferrer({ code: config.referralCode });
+  return { referralCode: config.referralCode, referralApplied: true };
+}
+
+// src/commands/init.ts
+register("init", {
+  description: "Create agent and emit resumable master-wallet approvals",
+  schema: z2.object({
+    masterAddress: z2.string().regex(/^0x[0-9a-fA-F]{40}$/).optional(),
+    signerType: z2.enum(["privy", "eoa"]).optional(),
+    eoaKeyRef: z2.string().regex(/^env:[A-Z_][A-Z0-9_]*$|^file:.+/).optional(),
+    validUntil: z2.number().int().optional(),
+    signature: z2.string().optional(),
+    builderSignature: z2.string().optional(),
+    qr: z2.boolean().default(true)
+  }),
+  execute: async (input, context) => {
+    rejectMasterKey(input);
+    const config = await loadConfig(context.configPath);
+    if (context.paper !== void 0) config.mode = context.paper ? "paper" : "live";
+    assertLiveMode(config, "init");
+    const signerType = input.signerType ?? config.signerType;
+    if (config.agentAddress && signerType !== config.signerType)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Initialized signer type differs; use a separate config for another agent"
+      );
+    config.signerType = signerType;
+    const stored = await readStoredConfig(context.configPath);
+    const requested = context.network ?? config.network;
+    if (stored?.approvedNetwork && requested !== stored.approvedNetwork)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Network does not match the approved network",
+        { network: requested, approvedNetwork: stored.approvedNetwork }
+      );
+    if (stored?.agentAddress && !stored.approvedNetwork && requested !== stored.network)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Initialized wallet network differs; use a separate config for another network"
+      );
+    if (config.agentAddress && config.masterAddress && input.masterAddress && input.masterAddress.toLowerCase() !== config.masterAddress.toLowerCase())
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Initialized master address differs; use a separate config for another account"
+      );
+    if (context.network) config.network = context.network;
+    if (!config.approvedNetwork) config.approvedNetwork = config.network;
+    else if (config.approvedNetwork !== config.network)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Network does not match the approved network",
+        { network: config.network, approvedNetwork: config.approvedNetwork }
+      );
+    config.masterAddress = input.masterAddress ?? config.masterAddress;
+    if (!config.masterAddress)
+      throw new AgentCliError("CONFIG_INVALID", "Provide masterAddress");
+    const expiry = input.validUntil ?? config.agentExpiry ?? Date.now() + 179 * 864e5;
+    if (expiry <= Date.now() || expiry > Date.now() + 180 * 864e5)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Expiry must be within 180 days"
+      );
+    config.agentExpiry = expiry;
+    let policyId;
+    if (signerType === "eoa") {
+      await prepareEoaAgent(
+        config,
+        context.configPath,
+        input.eoaKeyRef
+      );
+    } else {
+      const client = await privyClient(config);
+      policyId = await applyPolicy(config, client, context.configPath);
+      await createAgent(config, client, context.configPath, policyId);
+    }
+    if (config.approved && !config.revoked)
+      return {
+        ...config,
+        policyId: config.policyId ?? null,
+        expiry: config.agentExpiry,
+        ...await ensureReferral(config)
+      };
+    const path = join(
+      stateDir(),
+      `approval-${config.network}-${config.agentAddress}.json`
+    );
+    const createApprovals = async () => {
+      const created = {
+        agent: await newApproval(config, "approveAgent", {
+          agentAddress: config.agentAddress,
+          agentName: `${config.agentName} valid_until ${expiry}`
+        })
+      };
+      if (config.builder.fee > 0 && config.builder.address)
+        created.builder = await newApproval(config, "approveBuilderFee", {
+          builder: config.builder.address,
+          maxFeeRate: `${config.builder.fee / 1e3}%`
+        });
+      return created;
+    };
+    let pending;
+    let regenerated = false;
+    try {
+      const stored2 = JSON.parse(await readFile2(path, "utf8"));
+      if (stored2.agent?.action && isFreshApproval(stored2.createdAt))
+        pending = {
+          agent: stored2.agent,
+          builder: stored2.builder,
+          createdAt: stored2.createdAt,
+          expiresAt: stored2.expiresAt ?? stored2.createdAt + APPROVAL_MAX_AGE_MS
+        };
+      else throw Object.assign(new Error("stale"), { code: "ESTALE" });
+    } catch (error) {
+      if (error.code !== "ENOENT" && error.code !== "ESTALE")
+        throw error;
+      regenerated = error.code === "ESTALE";
+      const created = await createApprovals();
+      pending = {
+        ...created,
+        createdAt: Date.now(),
+        expiresAt: Date.now() + APPROVAL_MAX_AGE_MS
+      };
+      await atomicWrite(path, JSON.stringify(pending));
+    }
+    if ((input.signature || input.builderSignature) && regenerated)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Approval payload expired; sign the regenerated payload",
+        { expiresAt: pending.expiresAt, approvals: pending }
+      );
+    const submit = async (approval2, signature) => {
+      try {
+        await submitApproval(config.network, approval2, signature);
+      } catch (error) {
+        if (error instanceof AgentCliError && error.details?.nonceRejected) {
+          const created = await createApprovals();
+          pending = {
+            ...created,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + APPROVAL_MAX_AGE_MS
+          };
+          await atomicWrite(path, JSON.stringify(pending));
+          throw new AgentCliError(
+            "CONFIG_INVALID",
+            "Approval nonce was rejected; sign the regenerated payload",
+            { expiresAt: pending.expiresAt, approvals: pending }
+          );
+        }
+        throw error;
+      }
+    };
+    if (input.signature) await submit(pending.agent, input.signature);
+    if (input.builderSignature && pending.builder)
+      await submit(pending.builder, input.builderSignature);
+    const agents = await hlInfo(
+      config.network,
+      "extraAgents",
+      { user: config.masterAddress }
+    );
+    config.approved = agents.some(
+      (agent) => agent.address.toLowerCase() === config.agentAddress?.toLowerCase() && agent.validUntil >= expiry
+    );
+    if (config.builder.fee > 0 && config.builder.address) {
+      const max = await hlInfo(config.network, "maxBuilderFee", {
+        user: config.masterAddress,
+        builder: config.builder.address
+      });
+      config.approved = config.approved && max >= config.builder.fee;
+    }
+    config.revoked = false;
+    await saveConfig(config, context.configPath);
+    const deeplink = `ethereum:${config.masterAddress}?request=${encodeURIComponent(JSON.stringify(pending.agent.typedData))}`;
+    return {
+      masterAddress: config.masterAddress,
+      agentAddress: config.agentAddress,
+      signerType,
+      expiry,
+      policyId: policyId ?? null,
+      approved: config.approved,
+      ...config.approved ? await ensureReferral(config) : { referralCode: config.referralCode, referralApplied: false },
+      requiresSignature: !config.approved,
+      approvalExpiresAt: pending.expiresAt,
+      approvals: pending,
+      deeplink,
+      ...await renderQr(deeplink, { enabled: input.qr })
+    };
+  }
+});
+
+// src/core/account.ts
+function collateralBalance(state) {
+  const equity = parseUsdc(state.marginSummary.accountValue, 8);
+  const pnl = (state.assetPositions ?? []).reduce(
+    (sum, { position }) => sum + parseUsdc(position.unrealizedPnl, 8),
+    0n
+  );
+  return formatUsdc(equity - pnl, 8);
+}
+
+// src/commands/fund.ts
+import { z as z3 } from "zod";
+
+// src/funding/signatures.ts
+function signatureSteps(deposit) {
+  return deposit.quote.steps.flatMap(
+    (step) => step.kind === "signature" ? step.items.map((item, index) => ({
+      id: `${step.id}:${index}`,
+      requiresSignature: !deposit.completedSteps.includes(
+        `${step.id}:${index}`
+      ),
+      payload: signaturePayload(item.data.sign),
+      deeplink: `ethereum:${deposit.recipient}?request=${encodeURIComponent(JSON.stringify(signaturePayload(item.data.sign)))}`,
+      post: item.data.post
+    })) : []
+  );
+}
+async function submitDepositSignature(depositId, stepId, signature, options = {}) {
+  if (!/^0x[0-9a-fA-F]{130}$/.test(signature))
+    throw new AgentCliError("CONFIG_INVALID", "Expected wallet signature");
+  const deposits = await readDeposits(options.path);
+  const deposit = deposits.find((d) => d.id === depositId);
+  if (!deposit) throw new AgentCliError("CONFIG_INVALID", "Unknown deposit");
+  const pending = signatureSteps(deposit).filter((s) => s.requiresSignature);
+  if (!pending.length) return { complete: true };
+  const step = pending[0];
+  if (step.id !== stepId)
+    throw new AgentCliError(
+      "CONFIG_INVALID",
+      "Submit signatures in step order",
+      { nextStep: step.id }
+    );
+  const post = step.post;
+  if (!post || post.method !== "POST" || !post.endpoint.startsWith("/") || post.endpoint.startsWith("//"))
+    throw new AgentCliError(
+      "UPSTREAM_ERROR",
+      "Invalid signature submission endpoint"
+    );
+  const base = options.base ?? (deposit.network === "testnet" ? "https://api.testnets.relay.link" : "https://api.relay.link");
+  const url = new URL(post.endpoint, base);
+  if (url.origin !== new URL(base).origin)
+    throw new AgentCliError(
+      "POLICY_REJECTED",
+      "Untrusted signature destination"
+    );
+  url.searchParams.set("signature", signature);
+  await (options.submit ?? jsonRequest)(url.toString(), post.body);
+  let steps = signatureSteps(deposit);
+  await updateDeposits(options.path, (fresh) => {
+    const current = fresh.find((item) => item.id === depositId);
+    if (!current) throw new AgentCliError("CONFIG_INVALID", "Unknown deposit");
+    if (!current.completedSteps.includes(step.id))
+      current.completedSteps.push(step.id);
+    steps = signatureSteps(current);
+  });
+  return { depositId, steps };
+}
+function signaturePayload(value) {
+  if (!value || typeof value !== "object") return value;
+  const sign = value;
+  if (sign.signatureKind === "eip712")
+    return {
+      domain: sign.domain,
+      types: sign.types,
+      primaryType: sign.primaryType,
+      message: sign.message ?? sign.value
+    };
+  return value;
+}
+
+// src/core/builder.ts
+async function approvedBuilder(config, fetchMaximum = (user, builder) => hlInfo(config.network, "maxBuilderFee", { user, builder })) {
+  if (config.builder.fee === 0) return void 0;
+  if (!config.builder.address) {
+    if (config.builder.fee)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Builder address is required for a fee"
+      );
+    return void 0;
+  }
+  if (!config.masterAddress)
+    throw new AgentCliError("AGENT_NOT_APPROVED", "Master address missing");
+  const maximum = await fetchMaximum(
+    config.masterAddress,
+    config.builder.address
+  );
+  if (config.builder.fee > maximum)
+    throw new AgentCliError(
+      "AGENT_NOT_APPROVED",
+      "Approve configured builder fee with master wallet",
+      { approvedMax: maximum, requested: config.builder.fee }
+    );
+  return { b: config.builder.address.toLowerCase(), f: config.builder.fee };
+}
+var builderRate = (config) => `${config.builder.fee / 1e3}%`;
+
+// src/commands/fund.ts
+var fundSchema = z3.object({
+  originChain: z3.number().int().positive().default(42161),
+  originCurrency: z3.string().default("0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),
+  originDecimals: z3.number().int().min(0).max(30).default(6),
+  amount: z3.string().default("10"),
+  qr: z3.boolean().default(true),
+  qrPath: z3.string().optional()
+});
+async function fund(config, input, dependencies = {}) {
+  if (!config.masterAddress)
+    throw new AgentCliError("AGENT_NOT_APPROVED", "Initialize master address");
+  const amount = parseUsdc(input.amount, input.originDecimals);
+  if (amount <= 0n)
+    throw new AgentCliError("INVALID_SIZE", "Positive funding amount required");
+  const route = JSON.stringify([
+    config.network,
+    config.masterAddress,
+    input.originChain,
+    input.originCurrency,
+    amount.toString()
+  ]);
+  const deposits = await readDeposits(dependencies.path);
+  let deposit = deposits.find(
+    (d) => d.route === route && d.expiresAt > Date.now() && d.state === "awaiting_funds"
+  );
+  if (!deposit) {
+    const quote = await (dependencies.relay ?? new RelayClient(
+      config.network === "testnet" ? "https://api.testnets.relay.link" : "https://api.relay.link"
+    )).quote({
+      user: config.masterAddress,
+      recipient: config.masterAddress,
+      originChainId: input.originChain,
+      originCurrency: input.originCurrency,
+      amount: amount.toString(),
+      destinationChainId: 1337,
+      destinationCurrency: PERPS_USDC,
+      useDepositAddress: true,
+      tradeType: "EXACT_INPUT"
+    });
+    const parsed2 = parseQuote(quote);
+    const quotedDecimals = quote.details.currencyIn?.currency?.decimals;
+    const quotedAmount = quote.details.currencyIn?.amount;
+    if (typeof quotedDecimals !== "number")
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Quote did not include origin token decimals"
+      );
+    if (quotedDecimals !== input.originDecimals)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Origin decimals do not match the quoted token",
+        { originDecimals: input.originDecimals, quoteDecimals: quotedDecimals }
+      );
+    if (quotedAmount !== amount.toString())
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Quote amount does not match the requested amount",
+        { requested: amount.toString(), quoted: quotedAmount ?? null }
+      );
+    if (amount < BigInt(parsed2.minAmount))
+      throw new AgentCliError("INVALID_SIZE", "Below minimum deposit", {
+        minimum: parsed2.minAmount
+      });
+    const baseline = dependencies.baseline ? await dependencies.baseline() : collateralBalance(
+      await hlInfo(config.network, "clearinghouseState", {
+        user: config.masterAddress
+      })
+    );
+    deposit = {
+      id: parsed2.depositId,
+      network: config.network,
+      recipient: config.masterAddress,
+      route,
+      quote,
+      expiresAt: parsed2.expiresAt,
+      state: "awaiting_funds",
+      baseline,
+      createdAt: Date.now(),
+      completedSteps: []
+    };
+    await updateDeposits(dependencies.path, (fresh) => {
+      const raced = fresh.find(
+        (item) => item.route === route && item.expiresAt > Date.now() && item.state === "awaiting_funds"
+      );
+      if (raced) deposit = raced;
+      else fresh.push(deposit);
+    });
+  }
+  const parsed = parseQuote(deposit.quote);
+  const received = formatUsdc(
+    BigInt(parsed.expectedReceived),
+    parsed.receivedDecimals
+  );
+  return {
+    ...parsed,
+    expectedReceived: parseUsdc(received, 8).toString(),
+    expectedReceivedHuman: received,
+    originChain: input.originChain,
+    originCurrency: input.originCurrency,
+    minDeposit: formatUsdc(BigInt(parsed.minAmount), input.originDecimals),
+    builderFeeRate: builderRate(config),
+    builderAddress: config.builder.address,
+    state: deposit.state,
+    signatureSteps: signatureSteps(deposit),
+    ...await (dependencies.qr ?? renderQr)(parsed.depositAddress, {
+      enabled: input.qr,
+      path: input.qrPath
+    })
+  };
+}
+register("fund", {
+  description: "Quote funding with address, QR and transparent fees",
+  schema: fundSchema,
+  execute: async (input, context) => {
+    const config = await loadConfig(context.configPath);
+    if (context.paper !== void 0) config.mode = context.paper ? "paper" : "live";
+    assertLiveMode(config, "fund");
+    if (context.network) config.network = context.network;
+    return fund(config, input);
+  }
+});
+
+// src/commands/deposit.ts
+import { z as z4 } from "zod";
+register("deposit", {
+  description: "Resume deposit steps or submit a master-wallet signature",
+  schema: z4.object({
+    depositId: z4.string(),
+    stepId: z4.string().optional(),
+    signature: z4.string().optional(),
+    abandon: z4.boolean().default(false)
+  }),
+  execute: async (input) => {
+    if (input.abandon) return abandonDeposit(input.depositId);
+    if (input.signature && input.stepId)
+      return submitDepositSignature(
+        input.depositId,
+        input.stepId,
+        input.signature
+      );
+    const deposit = (await readDeposits()).find(
+      (d) => d.id === input.depositId
+    );
+    if (!deposit) throw new AgentCliError("CONFIG_INVALID", "Unknown deposit");
+    return { depositId: deposit.id, steps: signatureSteps(deposit) };
+  }
+});
+
+// src/runner/health.ts
+function health(runner, now = Date.now()) {
+  const subscriptions = runner.subscriptions;
+  return {
+    pid: String(runner.info.pid),
+    uptimeSeconds: String(Math.max(0, (now - runner.info.startedAt) / 1e3)),
+    wsState: subscriptions?.state ?? "disconnected",
+    wsStale: !subscriptions || now - subscriptions.lastMessage > 9e4,
+    lastFillTime: subscriptions?.lastFill ?? null,
+    signingSession: runner.signer ? "ready" : runner.config.mode === "paper" ? "simulated" : "unavailable"
+  };
+}
+async function runnerHealth(mode = "live") {
+  if (activeRunner && activeRunner.config.mode === mode) return health(activeRunner);
+  const info = await runningInfo(runnerPidPath(mode));
+  return info ? {
+    pid: String(info.pid),
+    uptimeSeconds: String((Date.now() - info.startedAt) / 1e3),
+    wsState: "unknown",
+    signingSession: mode === "paper" ? "simulated" : "unknown"
+  } : null;
+}
+function startHeartbeat(runner, subscriptions) {
+  runner.subscriptions = subscriptions;
+  let queue = Promise.resolve();
+  const tick = () => {
+    queue = queue.then(async () => {
+      await events.append("runner_state", health(runner));
+      await expiryWarnings(runner.config);
+      if (runner.config.masterAddress) {
+        const state = await hlInfo(runner.config.network, "clearinghouseState", {
+          user: runner.config.masterAddress
+        });
+        await pollDeposits(
+          runner.config.network,
+          runner.config.masterAddress,
+          collateralBalance(state),
+          {
+            emit: async (deposit) => {
+              await events.append("deposit", {
+                id: deposit.id,
+                state: deposit.state
+              });
+            }
+          }
+        );
+      }
+    }).catch(async (error) => {
+      await events.append("error", normalizeError(error).toJSON());
+    });
+  };
+  tick();
+  const timer = setInterval(tick, 3e4);
+  runner.onShutdown(async () => {
+    clearInterval(timer);
+    await queue;
+  });
+}
+
+// src/commands/read.ts
+import { z as z5 } from "zod";
+function accountBalance(state) {
+  return {
+    accountValue: state.marginSummary.accountValue,
+    accountValueUnits: parseUsdc(
+      state.marginSummary.accountValue,
+      8
+    ).toString(),
+    withdrawable: state.withdrawable,
+    marginUsed: state.marginSummary.totalMarginUsed
+  };
+}
+function positions(state) {
+  return state.assetPositions.map(({ position: p }) => ({
+    coin: p.coin,
+    size: p.szi,
+    entryPrice: p.entryPx,
+    unrealizedPnl: p.unrealizedPnl,
+    liquidationPrice: p.liquidationPx,
+    leverage: String(p.leverage.value),
+    marginMode: p.leverage.type
+  }));
+}
+function expiryStatus(config, now = Date.now()) {
+  const days = config.agentExpiry === void 0 ? null : Math.max(0, (config.agentExpiry - now) / 864e5);
+  return {
+    expiry: config.agentExpiry ?? null,
+    daysRemaining: days === null ? null : String(days),
+    warnings: days === null ? [] : config.expiryWarningDays.filter((threshold) => days <= threshold).map((threshold) => `Agent expires within ${threshold} days`)
+  };
+}
+async function paperRead(name, config) {
+  const store = new PaperStore();
+  const data = paperData();
+  const [state, marks] = await Promise.all([store.load(), data.marks()]);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const coin of new Set(state.positions.map((p) => p.coin)))
+    resolved.set(coin, await data.maxLeverageOf(coin));
+  const maxLeverageOf = (coin) => resolved.get(coin) ?? 1;
+  if (name === "orders") return paperOpenOrders(state);
+  const account = paperAccountState(state, marks, maxLeverageOf);
+  if (name === "balance") return accountBalance(account);
+  if (name === "positions") return positions(account);
+  return {
+    balance: accountBalance(account),
+    positions: positions(account),
+    mode: "paper",
+    dataNetwork: paperDataNetwork,
+    paper: {
+      startingBalance: state.startingBalance,
+      realizedPnl: state.realizedPnl,
+      feesPaid: state.feesPaid,
+      fundingPaid: state.fundingPaid,
+      openOrders: state.orders.length,
+      liquidations: state.liquidations
+    },
+    policy: {
+      id: config.policyId ?? null,
+      version: String(config.policyVersion ?? 0)
+    },
+    deposits: [],
+    runner: await runnerHealth("paper")
+  };
+}
+async function readCommand(name, config) {
+  if (config.mode === "paper") return paperRead(name, config);
+  if (!config.masterAddress)
+    throw new AgentCliError("AGENT_NOT_APPROVED", "Initialize master address");
+  try {
+    if (name === "orders")
+      return (await hlInfo(config.network, "frontendOpenOrders", {
+        user: config.masterAddress
+      })).map(
+        (order) => Object.fromEntries(
+          Object.entries(order).map(([key, value]) => [
+            key,
+            typeof value === "number" ? String(value) : value
+          ])
+        )
+      );
+    const state = await hlInfo(
+      config.network,
+      "clearinghouseState",
+      { user: config.masterAddress }
+    );
+    if (name === "balance") return accountBalance(state);
+    if (name === "positions") return positions(state);
+    const [agents, deposits, maxBuilderFee] = await Promise.all([
+      hlInfo(
+        config.network,
+        "extraAgents",
+        { user: config.masterAddress }
+      ),
+      pollDeposits(
+        config.network,
+        config.masterAddress,
+        collateralBalance(state),
+        {
+          emit: activeRunner ? async (deposit) => {
+            await events.append("deposit", {
+              id: deposit.id,
+              state: deposit.state
+            });
+          } : void 0
+        }
+      ),
+      config.builder.fee > 0 && config.builder.address ? hlInfo(config.network, "maxBuilderFee", {
+        user: config.masterAddress,
+        builder: config.builder.address
+      }) : Promise.resolve(0)
+    ]);
+    return {
+      balance: accountBalance(state),
+      positions: positions(state),
+      agent: {
+        address: config.agentAddress,
+        approved: agents.some(
+          (a) => a.address.toLowerCase() === config.agentAddress?.toLowerCase()
+        ),
+        revoked: config.revoked,
+        ...expiryStatus(config)
+      },
+      policy: {
+        id: config.policyId ?? null,
+        version: String(config.policyVersion ?? 0)
+      },
+      deposits: deposits.map((d) => ({ id: d.id, state: d.state })),
+      approvedMaxBuilderFee: String(maxBuilderFee),
+      runner: await runnerHealth()
+    };
+  } catch (error) {
+    throw mapHyperliquidError(error);
+  }
+}
+async function commandConfig(context) {
+  const config = await loadConfig(context.configPath);
+  if (context.network) config.network = context.network;
+  if (context.paper !== void 0) config.mode = context.paper ? "paper" : "live";
+  return config;
+}
+for (const name of ["status", "balance", "positions", "orders"])
+  register(name, {
+    description: `Read account ${name}`,
+    schema: z5.object({}),
+    execute: async (_input, context) => readCommand(name, await commandConfig(context))
+  });
+
+// src/commands/order.ts
+import { z as z6 } from "zod";
+var orderSchema = z6.object({
+  coin: z6.string(),
+  side: z6.enum(["buy", "sell"]),
+  size: z6.string(),
+  price: z6.string().optional(),
+  type: z6.enum(["limit", "market", "tp", "sl"]).default("limit"),
+  tif: z6.enum(["Gtc", "Ioc", "Alo"]).default("Gtc"),
+  reduceOnly: z6.boolean().default(false),
+  cloid: z6.string().regex(/^0x[0-9a-fA-F]{32}$/).optional(),
+  triggerPrice: z6.string().optional(),
+  slippage: z6.number().min(0).max(0.1).default(0.01),
+  intent: z6.string().optional()
+});
+async function prepareOrder(config, input, services) {
+  const market = await services.market(input.coin);
+  const size = roundSize(input.size, market.szDecimals);
+  let price = input.price;
+  if (input.type === "market" || (input.type === "tp" || input.type === "sl") && !price) {
+    const mid = (await services.mids())[input.coin];
+    if (!mid) throw new AgentCliError("UNKNOWN_MARKET", "Missing market price");
+    price = boundedMarketPrice(
+      mid,
+      input.slippage,
+      input.side,
+      market.szDecimals
+    );
+  }
+  if (!price) throw new AgentCliError("INVALID_PRICE", "Provide limit price");
+  price = roundPrice(price, market.szDecimals);
+  await checkRisk(
+    config,
+    {
+      coin: input.coin,
+      size,
+      price,
+      side: input.side,
+      leverage: 1,
+      reduceOnly: input.reduceOnly
+    },
+    services
+  );
+  let type = {
+    limit: { tif: input.type === "market" ? "Ioc" : input.tif }
+  };
+  if (input.type === "tp" || input.type === "sl") {
+    if (!input.triggerPrice)
+      throw new AgentCliError("INVALID_PRICE", "Trigger price required");
+    type = {
+      trigger: {
+        isMarket: !input.price,
+        triggerPx: roundPrice(input.triggerPrice, market.szDecimals),
+        tpsl: input.type
+      }
+    };
+  }
+  return {
+    a: market.asset,
+    b: input.side === "buy",
+    p: price,
+    s: size,
+    r: input.reduceOnly,
+    t: type,
+    c: input.cloid
+  };
+}
+function annotate(error, cloid) {
+  if (error instanceof AgentCliError) {
+    const details = error.details && typeof error.details === "object" && !Array.isArray(error.details) ? { ...error.details, cloid } : { cloid };
+    return new AgentCliError(error.code, error.message, details, error.retryable);
+  }
+  return new AgentCliError(
+    "INTERNAL",
+    error instanceof Error ? error.message : String(error),
+    { cloid }
+  );
+}
+async function placeOrder(config, input, services) {
+  const cloid = input.cloid ?? newCloid();
+  const orderInput = { ...input, cloid };
+  try {
+    return await withTradeLock(config, async () => {
+      await assertCanTrade(config, { reduceOnly: orderInput.reduceOnly });
+      const clients = services ?? await servicesForMode(config);
+      const existing = await clients.orderByCloid(cloid);
+      const builder = config.builder.fee === 0 ? void 0 : config.mode === "paper" ? { b: config.builder.address.toLowerCase(), f: config.builder.fee } : await approvedBuilder(config);
+      if (existing)
+        return {
+          result: existing,
+          builderFeeRate: builderRate(config),
+          builderAddress: config.builder.address,
+          cloid,
+          idempotent: true
+        };
+      const order = await prepareOrder(config, orderInput, clients);
+      const result = await exchangeAction(
+        "order",
+        () => clients.exchange.order({
+          orders: [order],
+          grouping: "na",
+          ...builder ? { builder } : {}
+        }),
+        cloid
+      );
+      return {
+        result,
+        builderFeeRate: builderRate(config),
+        builderAddress: config.builder.address,
+        cloid,
+        idempotent: false
+      };
+    });
+  } catch (error) {
+    throw annotate(error, cloid);
+  }
+}
+register("order", {
+  description: "Place limit, IOC market or TP/SL order",
+  schema: orderSchema,
+  execute: async (input, context) => placeOrder(await commandConfig(context), input)
+});
+function boundedMarketPrice(mid, slippage, side, szDecimals) {
+  const units = parseUsdc(mid, 18);
+  const ratio = BigInt(Math.round(slippage * 1e9));
+  const bound = units * (side === "buy" ? 1000000000n + ratio : 1000000000n - ratio) / 1000000000n;
+  const rounded = roundPrice(formatUsdc(bound, 18), szDecimals);
+  if (side === "buy" || parseUsdc(rounded, 18) >= bound) return rounded;
+  const precision = Math.max(
+    0,
+    Math.min(
+      6 - szDecimals,
+      4 - Math.floor(Math.log10(Number(formatUsdc(bound, 18))))
+    )
+  );
+  const tick = 10n ** BigInt(18 - precision);
+  return formatUsdc(parseUsdc(rounded, 18) + tick, 18);
+}
+
+// src/commands/cancel.ts
+import { z as z7 } from "zod";
+var cancelSchema = z7.object({
+  oid: z7.number().int().positive().optional(),
+  oids: z7.array(z7.number().int().positive()).optional(),
+  cloid: z7.string().optional(),
+  cloids: z7.array(z7.string()).optional(),
+  coin: z7.string().optional(),
+  all: z7.boolean().default(false),
+  intent: z7.string().optional()
+});
+async function cancelOrders(config, input, services) {
+  return withTradeLock(config, () => cancelLocked(config, input, services));
+}
+async function cancelLocked(config, input, services) {
+  await assertCanTrade(config, { cancel: true });
+  const clients = services ?? await servicesForMode(config);
+  const orders = await clients.orders();
+  const oids = input.oids ?? (input.oid ? [input.oid] : []), cloids = input.cloids ?? (input.cloid ? [input.cloid] : []);
+  if (!input.all && !input.coin && !oids.length && !cloids.length)
+    throw new AgentCliError("CONFIG_INVALID", "Select oid, cloid, coin or all");
+  for (const oid of oids)
+    if (!orders.some((o) => o.oid === oid))
+      throw new AgentCliError("ORDER_NOT_FOUND", `Order ${oid} absent`);
+  for (const cloid of cloids)
+    if (!orders.some((o) => o.cloid === cloid))
+      throw new AgentCliError("ORDER_NOT_FOUND", `Order ${cloid} absent`);
+  const selected = orders.filter(
+    (o) => (!input.coin || o.coin === input.coin) && (input.all || input.coin && !oids.length && !cloids.length || oids.includes(o.oid) || !!o.cloid && cloids.includes(o.cloid))
+  );
+  const cancels = await Promise.all(
+    selected.map(async (o) => ({
+      a: (await clients.market(o.coin)).asset,
+      o: o.oid
+    }))
+  );
+  if (!cancels.length) return { cancelled: [], result: null };
+  return {
+    cancelled: selected.map((o) => String(o.oid)),
+    result: await exchangeAction(
+      "cancel",
+      () => clients.exchange.cancel({ cancels })
+    )
+  };
+}
+register("cancel", {
+  description: "Cancel by oid/cloid, coin or all",
+  schema: cancelSchema,
+  execute: async (input, context) => cancelOrders(
+    await commandConfig(context),
+    input
+  )
+});
+
+// src/commands/modify.ts
+import { z as z8 } from "zod";
+var modification = z8.object({
+  oid: z8.number().int().positive().optional(),
+  cloid: z8.string().regex(/^0x[0-9a-fA-F]{32}$/).optional(),
+  size: z8.string().optional(),
+  price: z8.string().optional()
+});
+var modifySchema = modification.extend({
+  modifications: z8.array(modification).optional(),
+  intent: z8.string().optional()
+});
+async function modifyOrders(config, input, services) {
+  return withTradeLock(config, () => modifyLocked(config, input, services));
+}
+async function modifyLocked(config, input, services) {
+  const clients = services ?? await servicesForMode(config);
+  const orders = await clients.orders();
+  const staged = [...orders];
+  const stagedServices = { ...clients, orders: async () => staged };
+  const requests = input.modifications ?? [input];
+  const originals = requests.map((request) => {
+    if (!request.oid && !request.cloid)
+      throw new AgentCliError("CONFIG_INVALID", "Specify oid or cloid");
+    const original = orders.find(
+      (o) => request.oid ? o.oid === request.oid : o.cloid === request.cloid
+    );
+    if (!original)
+      throw new AgentCliError("ORDER_NOT_FOUND", "Resting order absent");
+    return original;
+  });
+  await assertCanTrade(config, {
+    reduceOnly: originals.length > 0 && originals.every((order) => order.reduceOnly)
+  });
+  const modifies = [];
+  for (const [requestIndex, request] of requests.entries()) {
+    const original = originals[requestIndex];
+    if (original.isTrigger && (!original.triggerPx || !/take profit|stop/i.test(original.orderType ?? "")))
+      throw new AgentCliError(
+        "UPSTREAM_ERROR",
+        "Trigger order metadata incomplete"
+      );
+    const market = await clients.market(original.coin);
+    const size = roundSize(request.size ?? original.sz, market.szDecimals);
+    const price = roundPrice(
+      request.price ?? original.limitPx,
+      market.szDecimals
+    );
+    await checkRisk(
+      config,
+      {
+        coin: original.coin,
+        size,
+        price,
+        side: original.side === "B" ? "buy" : "sell",
+        leverage: 1,
+        reduceOnly: original.reduceOnly
+      },
+      stagedServices,
+      original.oid
+    );
+    const index = staged.findIndex((order) => order.oid === original.oid);
+    staged[index] = { ...original, sz: size, limitPx: price };
+    modifies.push({
+      oid: request.cloid ?? original.oid,
+      order: {
+        a: market.asset,
+        b: original.side === "B",
+        p: price,
+        s: size,
+        r: original.reduceOnly ?? false,
+        t: original.isTrigger ? {
+          trigger: {
+            triggerPx: roundPrice(original.triggerPx, market.szDecimals),
+            isMarket: /market/i.test(original.orderType),
+            tpsl: /take profit/i.test(original.orderType) ? "tp" : "sl"
+          }
+        } : { limit: { tif: original.tif ?? "Gtc" } },
+        ...original.cloid ? { c: original.cloid } : {}
+      }
+    });
+  }
+  return exchangeAction(
+    "batchModify",
+    () => clients.exchange.batchModify({ modifies })
+  );
+}
+register("modify", {
+  description: "Modify price/size of single or batch resting orders",
+  schema: modifySchema,
+  execute: async (input, context) => modifyOrders(
+    await commandConfig(context),
+    input
+  )
+});
+
+// src/commands/leverage.ts
+import { z as z9 } from "zod";
+var leverageSchema = z9.object({
+  coin: z9.string(),
+  leverage: z9.number().int().positive(),
+  mode: z9.enum(["cross", "isolated"]).default("cross"),
+  intent: z9.string().optional()
+});
+async function setLeverage(config, input, services) {
+  return withTradeLock(config, async () => {
+    await assertCanTrade(config);
+    const clients = services ?? await servicesForMode(config);
+    const market = await clients.market(input.coin);
+    if (config.allowedMarkets.length && !config.allowedMarkets.includes(input.coin) || input.leverage > Math.min(market.maxLeverage, config.limits.maxLeverage ?? Infinity))
+      throw new AgentCliError(
+        "POLICY_REJECTED",
+        "Leverage or market exceeds configured limits"
+      );
+    if (config.limits.dailyLoss !== void 0 && parseUsdc(await requiredDailyLoss(clients), 8) > parseUsdc(String(config.limits.dailyLoss), 8))
+      throw new AgentCliError("POLICY_REJECTED", "Daily loss cap exceeded");
+    return exchangeAction(
+      "updateLeverage",
+      () => clients.exchange.updateLeverage({
+        asset: market.asset,
+        isCross: input.mode === "cross",
+        leverage: input.leverage
+      })
+    );
+  });
+}
+register("leverage", {
+  description: "Set market leverage and cross/isolated margin mode",
+  schema: leverageSchema,
+  execute: async (input, context) => setLeverage(
+    await commandConfig(context),
+    input
+  )
+});
+
+// src/runner/subscriptions.ts
+import { SubscriptionClient, WebSocketTransport } from "@bloxwap/hyperliquid";
+import WebSocket from "ws";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join2 } from "path";
+function subscriptionSet(config) {
+  return [
+    "userEvents",
+    "userFills",
+    "orderUpdates",
+    "clearinghouseState",
+    ...config.allowedMarkets.length ? ["allMids", ...config.allowedMarkets.map((coin) => `l2Book:${coin}`)] : []
+  ];
+}
+var Subscriptions = class {
+  constructor(runner, backend, emit) {
+    this.runner = runner;
+    this.backend = backend;
+    this.emit = emit;
+  }
+  runner;
+  backend;
+  emit;
+  state = "connecting";
+  lastMessage = Date.now();
+  lastFill = null;
+  seen = /* @__PURE__ */ new Set();
+  queue = Promise.resolve();
+  subscriptions = [];
+  async start() {
+    const path = join2(this.runner.directory, "subscriptions.json");
+    try {
+      const saved = JSON.parse(await readFile3(path, "utf8"));
+      this.seen = new Set(saved.seen);
+      this.lastFill = saved.lastFill;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    for (const tid of await this.journalTids()) this.seen.add(tid);
+    for (const fill of await this.backend.gap(this.lastFill ?? void 0))
+      await this.fill(fill);
+    this.backend.onState((state) => {
+      const reconnect = this.state !== "connecting" && state === "connected";
+      this.state = state;
+      this.lastMessage = Date.now();
+      if (reconnect)
+        this.enqueue(async () => {
+          for (const fill of await this.backend.gap(
+            this.lastFill ?? Date.now() - 6e4
+          ))
+            await this.fill(fill);
+          await this.emit("runner_state", { wsState: state });
+        });
+    });
+    for (const name of subscriptionSet(this.runner.config)) {
+      const [type, coin] = name.split(":");
+      const params = coin ? { coin } : type === "allMids" ? {} : { user: this.runner.config.masterAddress };
+      this.subscriptions.push(
+        await this.backend.subscribe(type, params, (data) => {
+          this.lastMessage = Date.now();
+          this.enqueue(async () => {
+            if (type === "userFills") {
+              for (const fill of data.fills)
+                await this.fill(fill);
+            } else if (type === "userEvents" && "fills" in data) {
+              for (const fill of data.fills)
+                await this.fill(fill);
+            } else if (type === "orderUpdates")
+              await this.emit("order_update", data);
+            else if (type === "clearinghouseState")
+              await this.emit("position_change", data);
+          });
+        })
+      );
+    }
+    this.runner.onShutdown(async () => {
+      await this.queue;
+      await Promise.all(this.subscriptions.map((s) => s.unsubscribe()));
+      await this.backend.close();
+    });
+  }
+  enqueue(operation) {
+    this.queue = this.queue.then(operation).catch(async (error) => {
+      await this.emit("error", normalizeError(error).toJSON());
+    });
+  }
+  async journalTids() {
+    try {
+      return (await readEvents(join2(this.runner.directory, "events.jsonl"))).filter((event) => event.type === "fill").map((event) => event.data.tid).filter((tid) => typeof tid === "number");
+    } catch {
+      return [];
+    }
+  }
+  async persist() {
+    await atomicWrite(
+      join2(this.runner.directory, "subscriptions.json"),
+      JSON.stringify({
+        seen: [...this.seen].slice(-1e4),
+        lastFill: this.lastFill
+      })
+    );
+  }
+  async fill(fill) {
+    if (this.seen.has(fill.tid)) return;
+    if ((await this.journalTids()).includes(fill.tid)) {
+      this.seen.add(fill.tid);
+      this.lastFill = Math.max(this.lastFill ?? 0, fill.time);
+      await this.persist();
+      return;
+    }
+    this.seen.add(fill.tid);
+    this.lastFill = Math.max(this.lastFill ?? 0, fill.time);
+    if (this.seen.size > 1e4)
+      this.seen.delete(this.seen.values().next().value);
+    await this.emit("fill", fill);
+    await this.persist();
+  }
+  async flush() {
+    await this.queue;
+  }
+};
+function sdkBackend(config) {
+  const transport = new WebSocketTransport({
+    isTestnet: config.network === "testnet",
+    resubscribe: true,
+    webSocketFactory: (url, protocols) => new WebSocket(url, protocols)
+  });
+  const client = new SubscriptionClient({ transport });
+  return {
+    subscribe: (type, params, listener) => client[type](params, listener),
+    onState: (listener) => transport.events.addEventListener(
+      "connectionstatechange",
+      (event) => listener(event.detail)
+    ),
+    close: async () => {
+      await transport.close();
+    },
+    gap: async (startTime = Date.now() - 6e4) => {
+      const fills = [];
+      const endTime = Date.now();
+      for (let page = 0; page < 100; page++) {
+        const batch = await hlInfo(config.network, "userFillsByTime", {
+          user: config.masterAddress,
+          startTime,
+          endTime
+        });
+        fills.push(...batch);
+        if (batch.length < 2e3) return fills;
+        const last = Math.max(...batch.map((fill) => fill.time));
+        if (last <= startTime)
+          throw new Error("Fill backfill cannot advance; inspect gap");
+        startTime = last;
+      }
+      throw new Error("Fill backfill exceeded pagination bound");
+    }
+  };
+}
+async function startSubscriptions(runner, emit) {
+  const subscriptions = new Subscriptions(
+    runner,
+    sdkBackend(runner.config),
+    emit
+  );
+  await subscriptions.start();
+  return subscriptions;
+}
+
+// src/commands/run.ts
+import { z as z10 } from "zod";
+
+// src/paper/engine.ts
+import { SubscriptionClient as SubscriptionClient2, WebSocketTransport as WebSocketTransport2 } from "@bloxwap/hyperliquid";
+import WebSocket2 from "ws";
+var PaperEngine = class {
+  constructor(runner, store, backend, emit, data = paperData(), builderFee = runner.config.builder.fee) {
+    this.runner = runner;
+    this.store = store;
+    this.backend = backend;
+    this.emit = emit;
+    this.data = data;
+    this.builderFee = builderFee;
+  }
+  runner;
+  store;
+  backend;
+  emit;
+  data;
+  builderFee;
+  state = "connecting";
+  lastMessage = Date.now();
+  lastFill = null;
+  books = /* @__PURE__ */ new Map();
+  lastTrade = /* @__PURE__ */ new Map();
+  subscriptions = [];
+  queue = Promise.resolve();
+  timer;
+  async start() {
+    this.backend.onState((state) => {
+      const reconnect = this.state !== "connecting" && state === "connected";
+      this.state = state;
+      this.lastMessage = Date.now();
+      if (reconnect)
+        this.enqueue(async () => {
+          await this.refreshSubscriptions();
+          await this.emit("runner_state", { wsState: state, paper: true });
+        });
+    });
+    await this.refreshSubscriptions();
+    this.timer = setInterval(() => {
+      this.enqueue(() => this.tick());
+    }, 3e4);
+    this.runner.onShutdown(async () => {
+      if (this.timer) clearInterval(this.timer);
+      await this.queue;
+      await Promise.all(
+        this.subscriptions.map((subscription) => subscription.handle.unsubscribe())
+      );
+      this.subscriptions = [];
+      await this.backend.close();
+    });
+    this.enqueue(() => this.tick());
+  }
+  enqueue(operation) {
+    this.queue = this.queue.then(operation).catch(async (error) => {
+      await this.emit("error", normalizeError(error).toJSON());
+    });
+  }
+  async activeCoins() {
+    const state = await this.store.load();
+    return [
+      .../* @__PURE__ */ new Set([
+        ...this.runner.config.allowedMarkets,
+        ...state.orders.map((order) => order.coin),
+        ...state.positions.map((position) => position.coin)
+      ])
+    ];
+  }
+  async refreshSubscriptions() {
+    const coins = await this.activeCoins();
+    for (const subscription of [...this.subscriptions]) {
+      if (!coins.includes(subscription.coin)) {
+        await subscription.handle.unsubscribe();
+        this.subscriptions = this.subscriptions.filter(
+          (candidate) => candidate !== subscription
+        );
+        this.books.delete(subscription.coin);
+      }
+    }
+    for (const coin of coins) {
+      for (const type of ["l2Book", "trades", "bbo"]) {
+        if (this.subscriptions.some((s) => s.coin === coin && s.type === type))
+          continue;
+        const handle = await this.backend.subscribe(
+          type,
+          { coin },
+          (message) => {
+            this.lastMessage = Date.now();
+            this.enqueue(() => this.handleMessage(type, coin, message));
+          }
+        );
+        this.subscriptions.push({ coin, type, handle });
+      }
+    }
+  }
+  async handleMessage(type, coin, message) {
+    if (type === "trades") {
+      for (const trade of message.trades ?? []) {
+        if (trade.coin === coin) this.lastTrade.set(coin, trade.px);
+      }
+      await this.match(coin);
+      return;
+    }
+    if (type === "l2Book") this.applyBookMessage(coin, message);
+    await this.match(coin);
+  }
+  applyBookMessage(coin, message) {
+    let book = this.books.get(coin) ?? { bids: [], asks: [] };
+    if (message.side) {
+      const side = message.side === "B" ? "bids" : "asks";
+      for (const level of message.levels[0] ?? []) {
+        const index = book[side].findIndex((existing) => existing.px === level.px);
+        if (Number(level.sz) === 0) {
+          if (index >= 0) book[side].splice(index, 1);
+        } else if (index >= 0) book[side][index].sz = level.sz;
+        else book[side].push({ px: level.px, sz: level.sz });
+      }
+      book.bids.sort((a, b) => Number(b.px) - Number(a.px));
+      book.asks.sort((a, b) => Number(a.px) - Number(b.px));
+    } else if (Array.isArray(message.levels)) {
+      book = { bids: message.levels[0] ?? [], asks: message.levels[1] ?? [] };
+    } else return;
+    this.books.set(coin, book);
+  }
+  async match(coin) {
+    const book = this.books.get(coin) ?? null;
+    const marks = await this.data.marks();
+    const result = await this.store.update(
+      (state) => matchOrders(
+        state,
+        coin,
+        {
+          bestBid: book?.bids[0]?.px,
+          bestAsk: book?.asks[0]?.px,
+          lastTradePx: this.lastTrade.get(coin),
+          markPx: marks[coin]
+        },
+        book,
+        this.builderFee,
+        Date.now()
+      )
+    );
+    await this.report(result);
+  }
+  async report(result) {
+    for (const trade of result.fills) {
+      this.lastFill = Math.max(this.lastFill ?? 0, trade.time);
+      await this.emit("fill", { ...trade, paper: true });
+    }
+    for (const oid of [...result.filledOids, ...result.triggeredOids])
+      await this.emit("order_update", { oid, status: "filled", paper: true });
+    for (const oid of result.cancelledOids)
+      await this.emit("order_update", { oid, status: "canceled", paper: true });
+    if (result.fills.length)
+      await this.emit("position_change", { fills: result.fills.length, paper: true });
+  }
+  async tick() {
+    await this.refreshSubscriptions();
+    const [marks, rates] = await Promise.all([
+      this.data.marks(),
+      this.data.fundingRates()
+    ]);
+    const now = Date.now();
+    const payments = await this.store.update(
+      (state2) => accrueFunding(state2, rates, marks, now)
+    );
+    for (const payment of payments)
+      await this.emit("position_change", { type: "funding", ...payment, paper: true });
+    const state = await this.store.load();
+    const maxLeverage = /* @__PURE__ */ new Map();
+    for (const coin of new Set(state.positions.map((position) => position.coin)))
+      maxLeverage.set(coin, await this.data.maxLeverageOf(coin));
+    const liquidated = await this.store.update(
+      (latest) => liquidate(latest, marks, (coin) => maxLeverage.get(coin) ?? 1, this.builderFee, now)
+    );
+    for (const trade of liquidated) {
+      await this.emit("fill", { ...trade, paper: true });
+      await this.emit("error", {
+        code: "INSUFFICIENT_MARGIN",
+        message: `Paper liquidation on ${trade.coin}`,
+        paper: true
+      });
+    }
+    await this.emit("runner_state", { ...health(this.runner), paper: true });
+  }
+  async flush() {
+    await this.queue;
+  }
+};
+function paperBackend() {
+  const transport = new WebSocketTransport2({
+    isTestnet: false,
+    // paper trading always reads mainnet public data
+    resubscribe: true,
+    webSocketFactory: (url, protocols) => new WebSocket2(url, protocols)
+  });
+  const client = new SubscriptionClient2({ transport });
+  return {
+    subscribe: (type, params, listener) => client[type](params, listener),
+    onState: (listener) => transport.events.addEventListener(
+      "connectionstatechange",
+      (event) => listener(event.detail)
+    ),
+    close: async () => {
+      await transport.close();
+    }
+  };
+}
+async function startPaperEngine(runner, emit, backend = paperBackend()) {
+  const engine = new PaperEngine(
+    runner,
+    new PaperStore(),
+    backend,
+    emit
+  );
+  await engine.start();
+  return engine;
+}
+
+// src/commands/run.ts
+register("run", {
+  description: "Start persistent signing runner (foreground or detach)",
+  schema: z10.object({
+    detach: z10.boolean().default(false),
+    daemon: z10.boolean().default(false),
+    paper: z10.boolean().default(false)
+  }),
+  execute: async (input, context) => {
+    const config = await commandConfig(context);
+    const paper = input.paper || config.mode === "paper";
+    if (input.detach || input.daemon)
+      return {
+        paper,
+        ...await detachRunner(
+          [
+            ...context.configPath ? ["--config", context.configPath] : [],
+            ...context.network ? ["--network", context.network] : [],
+            ...paper ? ["--paper"] : []
+          ],
+          runnerPidPath(paper ? "paper" : "live")
+        )
+      };
+    if (paper) {
+      const runner2 = new Runner(config, paperDir());
+      const info2 = await runner2.start(async () => void 0);
+      if (!info2.existing) {
+        setActiveRunner(runner2);
+        runner2.signals();
+        runner2.onShutdown(() => paperEvents.flush());
+        try {
+          await rpcServer(runner2, context);
+          await startPaperEngine(runner2, async (type, data) => {
+            if (eventTypes.includes(type))
+              await paperEvents.append(type, data);
+            runner2.logger.log(type === "error" ? "error" : "info", type, {
+              data
+            });
+          });
+          await runner2.markReady();
+        } catch (error) {
+          await runner2.shutdown();
+          throw error;
+        }
+      }
+      return {
+        paper: true,
+        ...info2,
+        ready: info2.existing ? info2.ready : runner2.info.ready
+      };
+    }
+    const runner = new Runner(config);
+    const info = await runner.start();
+    if (!info.existing) {
+      setActiveRunner(runner);
+      runner.signals();
+      runner.onShutdown(() => events.flush());
+      try {
+        await rpcServer(runner, context);
+        const subscriptions = await startSubscriptions(
+          runner,
+          async (type, data) => {
+            if (eventTypes.includes(type))
+              await events.append(type, data);
+            runner.logger.log(type === "error" ? "error" : "info", type, {
+              data
+            });
+          }
+        );
+        startHeartbeat(runner, subscriptions);
+        await runner.markReady();
+      } catch (error) {
+        await runner.shutdown();
+        throw error;
+      }
+    }
+    return {
+      paper: false,
+      ...info,
+      ready: info.existing ? info.ready : runner.info.ready
+    };
+  }
+});
+
+// src/commands/events.ts
+import { z as z11 } from "zod";
+import { join as join3 } from "path";
+register("events", {
+  description: "Replay or follow JSON-line runner events",
+  schema: z11.object({
+    follow: z11.boolean().default(false),
+    since: z11.number().int().nonnegative().default(0),
+    types: z11.array(z11.enum(eventTypes)).default([])
+  }),
+  execute: async (input, context) => {
+    const paper = await resolveMode(context, "events") === "paper";
+    const path = paper ? join3(paperDir(), "events.jsonl") : join3(stateDir(), "events.jsonl");
+    if (!input.follow)
+      return readEvents(
+        path,
+        input.since,
+        input.types
+      );
+    context.streaming = true;
+    const abort = new AbortController();
+    const stop = () => abort.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+      await followEvents({
+        path,
+        since: input.since,
+        types: input.types,
+        signal: abort.signal,
+        write: (event) => process.stdout.write(JSON.stringify(event) + "\n")
+      });
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+    return null;
+  }
+});
+
+// src/commands/logs.ts
+import { z as z12 } from "zod";
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
+async function readLogs(options = {}) {
+  const directory = options.directory ?? join4(stateDir(), "logs");
+  let files;
+  try {
+    files = await readdir(directory);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const lines = (await Promise.all(
+    files.filter((f) => /^runner.*\.jsonl$/.test(f)).map((f) => readFile4(join4(directory, f), "utf8"))
+  )).flatMap(
+    (content) => content.split("\n").slice(0, -1).filter(Boolean).map((line) => JSON.parse(line))
+  );
+  return lines.filter(
+    (line) => (!options.level || levels[line.level] >= levels[options.level]) && (!options.since || String(line.time) >= options.since) && (!options.requestId || line.requestId === options.requestId)
+  ).sort((a, b) => String(a.time).localeCompare(String(b.time))).map(redact);
+}
+register("logs", {
+  description: "Read/follow redacted JSON-line runner logs",
+  schema: z12.object({
+    follow: z12.boolean().default(false),
+    level: z12.enum(["debug", "info", "warn", "error"]).optional(),
+    since: z12.string().datetime().optional(),
+    requestId: z12.string().optional()
+  }),
+  execute: async (input, context) => {
+    context.streaming = true;
+    const paper = await resolveMode(context, "logs") === "paper";
+    const directory = paper ? join4(paperDir(), "logs") : join4(stateDir(), "logs");
+    let cursor = 0;
+    const seen = /* @__PURE__ */ new Set();
+    const abort = new AbortController();
+    const stop = () => abort.abort();
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+      do {
+        const logs = await readLogs({ ...input, directory });
+        for (const log of logs) {
+          const key = JSON.stringify(log);
+          if (!seen.has(key)) {
+            seen.add(key);
+            process.stdout.write(key + "\n");
+            cursor++;
+          }
+        }
+        if (input.follow && !abort.signal.aborted)
+          await new Promise((resolve) => setTimeout(resolve, 250));
+      } while (input.follow && !abort.signal.aborted);
+    } finally {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+    }
+    return { lines: cursor };
+  }
+});
+
+// src/commands/rotate.ts
+import { z as z13 } from "zod";
+import { join as join5 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+async function rotationHandoff(rotation, dependencies) {
+  if (!await dependencies.verify())
+    throw new AgentCliError(
+      "AGENT_NOT_APPROVED",
+      "New agent approval not visible; old agent remains active"
+    );
+  if (!rotation.swapped) {
+    await dependencies.swap(rotation.next);
+    rotation.swapped = true;
+    await dependencies.persist();
+  }
+  return rotation.revoke;
+}
+register("rotate", {
+  description: "Approve new agent, hot-swap signer, then revoke old agent",
+  schema: z13.object({
+    signature: z13.string().optional(),
+    revokeSignature: z13.string().optional(),
+    eoaKeyRef: z13.string().regex(/^env:[A-Z_][A-Z0-9_]*$|^file:.+/).optional()
+  }),
+  execute: async (input, context) => {
+    const current = await commandConfig(context);
+    assertLiveMode(current, "rotate");
+    assertApprovedNetwork(current);
+    if (!current.masterAddress || !current.agentAddress)
+      throw new AgentCliError("AGENT_NOT_APPROVED", "Initialize first");
+    const path = join5(
+      stateDir(),
+      `rotation-${current.network}-${current.masterAddress}.json`
+    );
+    let rotation;
+    const client = current.signerType === "privy" ? await privyClient(current) : void 0;
+    try {
+      rotation = JSON.parse(await readFile5(path, "utf8"));
+      if (rotation.revoked && !input.signature && !input.revokeSignature) {
+        await atomicWrite(
+          `${path}.${Date.now()}.previous`,
+          JSON.stringify(rotation)
+        );
+        throw Object.assign(new Error("Begin next rotation"), {
+          code: "ENOENT"
+        });
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const next = {
+        ...structuredClone(current),
+        privyWalletId: void 0,
+        agentAddress: void 0,
+        authorizationKeyRef: void 0,
+        eoaKeyRef: void 0,
+        agentExpiry: Date.now() + 179 * 864e5,
+        approved: false,
+        revoked: false
+      };
+      if (current.signerType === "eoa") {
+        await prepareEoaAgent(
+          next,
+          join5(stateDir(), "rotation-next.json"),
+          input.eoaKeyRef
+        );
+      } else {
+        await createAgent(
+          next,
+          client,
+          join5(stateDir(), "rotation-next.json"),
+          current.policyId
+        );
+      }
+      if (next.agentAddress === current.agentAddress)
+        throw new AgentCliError(
+          "CONFIG_INVALID",
+          "Rotation requires a different EOA agent key"
+        );
+      next.agentName = `blox-${next.agentAddress.slice(-8)}`;
+      const now = Date.now();
+      rotation = {
+        old: current,
+        next,
+        approval: await newApproval(current, "approveAgent", {
+          agentAddress: next.agentAddress,
+          agentName: `${next.agentName} valid_until ${next.agentExpiry}`
+        }),
+        revoke: await newApproval(current, "approveAgent", {
+          agentAddress: "0x" + "0".repeat(40),
+          agentName: current.agentName
+        }),
+        approvalCreatedAt: now,
+        approvalExpiresAt: now + APPROVAL_MAX_AGE_MS,
+        revokeCreatedAt: now,
+        revokeExpiresAt: now + APPROVAL_MAX_AGE_MS,
+        swapped: false,
+        revoked: false
+      };
+      await atomicWrite(path, JSON.stringify(rotation));
+    }
+    if (!rotation.swapped && !isFreshApproval(rotation.approvalCreatedAt)) {
+      const now = Date.now();
+      rotation.approval = await newApproval(current, "approveAgent", {
+        agentAddress: rotation.next.agentAddress,
+        agentName: `${rotation.next.agentName} valid_until ${rotation.next.agentExpiry}`
+      });
+      rotation.approvalCreatedAt = now;
+      rotation.approvalExpiresAt = now + APPROVAL_MAX_AGE_MS;
+      await atomicWrite(path, JSON.stringify(rotation));
+      if (input.signature)
+        throw new AgentCliError(
+          "CONFIG_INVALID",
+          "Approval payload expired; sign the regenerated payload",
+          { expiresAt: rotation.approvalExpiresAt, approval: rotation.approval }
+        );
+    }
+    if (!rotation.revoked && !isFreshApproval(rotation.revokeCreatedAt)) {
+      const now = Date.now();
+      rotation.revoke = await newApproval(current, "approveAgent", {
+        agentAddress: "0x" + "0".repeat(40),
+        agentName: rotation.old.agentName
+      });
+      rotation.revokeCreatedAt = now;
+      rotation.revokeExpiresAt = now + APPROVAL_MAX_AGE_MS;
+      await atomicWrite(path, JSON.stringify(rotation));
+      if (input.revokeSignature)
+        throw new AgentCliError(
+          "CONFIG_INVALID",
+          "Revoke payload expired; sign the regenerated payload",
+          {
+            expiresAt: rotation.revokeExpiresAt,
+            revokeApproval: rotation.revoke
+          }
+        );
+    }
+    const refreshSigned = async (kind, signature) => {
+      try {
+        await submitApproval(current.network, rotation[kind], signature);
+      } catch (error) {
+        if (!(error instanceof AgentCliError) || !error.details?.nonceRejected)
+          throw error;
+        const now = Date.now();
+        rotation[kind] = await newApproval(current, "approveAgent", {
+          agentAddress: kind === "approval" ? rotation.next.agentAddress : "0x" + "0".repeat(40),
+          agentName: kind === "approval" ? `${rotation.next.agentName} valid_until ${rotation.next.agentExpiry}` : rotation.old.agentName
+        });
+        if (kind === "approval") {
+          rotation.approvalCreatedAt = now;
+          rotation.approvalExpiresAt = now + APPROVAL_MAX_AGE_MS;
+        } else {
+          rotation.revokeCreatedAt = now;
+          rotation.revokeExpiresAt = now + APPROVAL_MAX_AGE_MS;
+        }
+        await atomicWrite(path, JSON.stringify(rotation));
+        throw new AgentCliError(
+          "CONFIG_INVALID",
+          "Approval nonce was rejected; sign the regenerated payload",
+          {
+            expiresAt: kind === "approval" ? rotation.approvalExpiresAt : rotation.revokeExpiresAt,
+            approval: rotation[kind]
+          }
+        );
+      }
+    };
+    if (input.signature) {
+      await refreshSigned("approval", input.signature);
+      await rotationHandoff(rotation, {
+        verify: async () => {
+          const agents = await hlInfo(current.network, "extraAgents", { user: current.masterAddress });
+          return agents.some(
+            (a) => a.address.toLowerCase() === rotation.next.agentAddress?.toLowerCase() && a.validUntil >= rotation.next.agentExpiry
+          );
+        },
+        swap: async (nextConfig) => {
+          const saved = await updateConfig(
+            context.configPath ?? configPath(),
+            (latest) => {
+              copyAgentFields(latest, nextConfig);
+              latest.approved = true;
+              latest.revoked = false;
+            }
+          );
+          const signer = await openSigner(saved);
+          if (activeRunner) {
+            activeRunner.signer = signer;
+            copyAgentFields(activeRunner.config, saved);
+            activeRunner.config.approved = true;
+            activeRunner.config.revoked = false;
+          }
+          await events.append("runner_state", {
+            rotation: {
+              old: rotation.old.agentAddress,
+              next: nextConfig.agentAddress
+            }
+          });
+        },
+        persist: () => atomicWrite(path, JSON.stringify(rotation))
+      });
+    }
+    if (input.revokeSignature) {
+      if (!rotation.swapped)
+        throw new AgentCliError(
+          "POLICY_REJECTED",
+          "Approve and swap new agent before revoking old"
+        );
+      await refreshSigned("revoke", input.revokeSignature);
+      rotation.revoked = true;
+      await atomicWrite(path, JSON.stringify(rotation));
+    }
+    return {
+      oldAgent: rotation.old.agentAddress,
+      newAgent: rotation.next.agentAddress,
+      swapped: rotation.swapped,
+      oldRevoked: rotation.revoked,
+      requiresSignature: !rotation.swapped,
+      approvalExpiresAt: rotation.approvalExpiresAt ?? null,
+      revokeExpiresAt: rotation.swapped ? rotation.revokeExpiresAt ?? null : void 0,
+      approval: rotation.approval,
+      ...rotation.swapped ? { revokeApproval: rotation.revoke } : {}
+    };
+  }
+});
+
+// src/commands/revoke.ts
+import { z as z14 } from "zod";
+import { join as join6 } from "path";
+function markRevoked(config) {
+  config.revoked = true;
+  config.approved = false;
+  return config;
+}
+register("revoke", {
+  description: "Disable local agent and prepare master-signed exchange revocation",
+  schema: z14.object({
+    cancelOrders: z14.boolean().default(false),
+    signature: z14.string().optional()
+  }),
+  execute: async (input, context) => {
+    const config = await commandConfig(context);
+    assertLiveMode(config, "revoke");
+    assertApprovedNetwork(config);
+    if (!config.agentAddress)
+      throw new AgentCliError("AGENT_NOT_APPROVED", "No agent to revoke");
+    if (input.cancelOrders && !config.revoked)
+      await cancelOrders(config, cancelSchema.parse({ all: true }));
+    const path = join6(
+      stateDir(),
+      `revoke-${config.network}-${config.agentAddress}.json`
+    );
+    const refresh = () => newApproval(config, "approveAgent", {
+      agentAddress: "0x" + "0".repeat(40),
+      agentName: config.agentName
+    });
+    const pending = await resolvePendingApproval(path, refresh);
+    let exchangeRevoked = false;
+    if (input.signature) {
+      await submitFreshApproval(
+        config.network,
+        path,
+        pending,
+        input.signature,
+        refresh
+      );
+      exchangeRevoked = true;
+      config.authorizationKeyRef = void 0;
+      config.privyWalletId = void 0;
+      config.eoaKeyRef = void 0;
+    }
+    markRevoked(config);
+    await saveConfig(config, context.configPath);
+    if (activeRunner) {
+      activeRunner.signer = void 0;
+      Object.assign(activeRunner.config, config);
+    }
+    return {
+      agentAddress: config.agentAddress,
+      locallyRevoked: true,
+      exchangeRevoked,
+      requiresSignature: !exchangeRevoked,
+      expiresAt: pending.expiresAt,
+      approval: pending.approval
+    };
+  }
+});
+
+// src/commands/audit.ts
+import { z as z15 } from "zod";
+register("audit", {
+  description: "Verify and query the hash-chained trading audit",
+  schema: z15.object({
+    intent: z15.string().optional(),
+    intentId: z15.string().optional(),
+    cloid: z15.string().optional()
+  }),
+  execute: async (input, context) => {
+    const entries = await readAudit(
+      auditStoreFor(await resolveMode(context)).path
+    );
+    verifyAudit(entries);
+    return entries.filter(
+      (entry) => (!input.intent && !input.intentId || entry.intentId === (input.intentId ?? input.intent)) && (!input.cloid || entry.cloid === input.cloid)
+    );
+  }
+});
+
+// src/commands/skill.ts
+import { z as z16 } from "zod";
+import { homedir } from "os";
+import { join as join7 } from "path";
+import { readFile as readFile6 } from "fs/promises";
+
+// src/core/skill-content.ts
+var cliVersion = "0.4.0";
+var skillContent = '---\nname: agent-cli\ndescription: Operate the agent-cli Hyperliquid trading CLI, including managed-agent onboarding, paper trading against real market data, funding, orders, event monitoring, rotation, and normalized error recovery.\nmetadata:\n  version: "0.4.0"\n---\n\nUse `agent-cli` for the user\'s authorized Hyperliquid account operations. Obtain\ncommand schemas with `agent-cli schema COMMAND`; arguments can be flags or\n`--json \'{...}\'`, or a JSON object on stdin. Ordinary commands print exactly one\nJSON object: `{ok:true,data,mode,paper}` or\n`{ok:false,code,message,retryable,details,mode,paper}`; `mode` is `"live"` or\n`"paper"` and `paper` is `true` in paper mode.\nLogs/QR appear on stderr. `events --follow` and `logs` explicitly stream JSON lines.\nUse `--network testnet` during testing; never silently change to mainnet.\n\n## Paper first, then fund and go live\n\nStart every strategy in paper mode: `agent-cli --paper ...`, `config set mode\npaper`, or `run --paper`. Paper mode runs against real mainnet Hyperliquid\npublic market data (info + WS l2Book/trades/bbo, meta, funding) and never signs\nor submits anything \u2014 no Privy session, `approveAgent`, or deposit is needed.\n`order`/`cancel`/`modify`/`leverage` keep the same validation, risk limits,\nbuilder fee and audit trail; a local simulator fills them (book-walking market\norders, resting limits, reduce-only, TP/SL, fees, funding, margin/liquidation\napproximation). State is restartable under `~/.bloxwap/paper/`; `paper summary`\nreports PnL/fees/funding, `paper reset --yes` clears it. Envelopes and events\ncarry `mode`/`paper`, paper state never mixes with live state, and going live\nrequires `config set mode live --yes`. Only after the paper results are proven,\ncontinue with live onboarding below and real funding.\n\n## Onboarding sequence\n\n1. The user owns all settings and chooses their own Privy app or dedicated EOA\n   agent; no wallet or credentials are bundled. For Privy, set `signerType` to\n   `privy` and configure the app ID and `privyAppSecretRef`. For EOA, set\n   `signerType` to `eoa` and configure `eoaKeyRef`, e.g. `env:BLOXWAP_EOA_KEY`\n   or a mode-0600 `file:` path.\n   The user creates the key and sets the secret outside the conversation on their\n   own machine or runner. Never accept raw keys in CLI input or use the master EOA\n   as the agent. Master-wallet approval always remains in the user\'s external wallet.\n   The default Bloxwap builder is `0x71b09A08257078A4d642F7Dd7315e656c837329a`,\n   with `f=0` (no builder fee). The default referral code is `BLOXWAP`; override\n   with `config set referralCode` or `BLOXWAP_REFERRAL_CODE`. Optional non-zero\n   builder fees use `config set builder.address` / `config set builder.fee` or\n   `BLOXWAP_BUILDER_ADDRESS` / `BLOXWAP_BUILDER_FEE`.\n2. Run `init --master-address 0x... --network testnet`. Show the returned approval\n   payload/deeplink/QR. The user signs in their master wallet; submit only the\n   resulting signature with `init --signature 0x...`. After agent approval, init\n   applies the configured referral if the account has none and leaves existing\n   referrals unchanged. Builder approval is needed only for a non-zero configured\n   fee. Continue only after `approved:true`.\n3. Run `fund --amount 10 --origin-chain 42161`. Show `qrAscii`/deposit address,\n   origin chain/token, minimum, fees, expected received amount and expiry. On\n   testnet, do not treat the default Arbitrum mainnet chain/token as a test route:\n   use an explicitly supported test chain/token and `originDecimals`, or the\n   credential-gated CI harness with mocked Relay and mocked Hyperliquid orders.\n   If no test route is known, stop funding and report the missing route. The user\n   transfers the quoted origin token. If `signatureSteps` require signatures,\n   show the exact payload and submit each via `deposit` in returned order.\n4. Poll `status` until each active deposit is `settled`, for at most 12 polls\n   or 5 minutes, whichever comes first. Start with 1-second delays, double to a\n   15-second cap, and stop with an explicit pending report if the budget expires.\n   Settlement requires Relay success and a positive Hyperliquid ledger deposit\n   (`userNonFundingLedgerUpdates`), not an unchanged equity balance. Stop on\n   failed, refunded, expired, or abandoned deposits and explain their status.\n   Quotes that never receive funds become `expired` 15 minutes after `expiresAt`.\n   `deposit --abandon` marks an unfinished deposit `abandoned`. Do not place\n   risk-increasing orders while a deposit is awaiting funds or pending. `cancel`\n   and reduce-only orders still run.\n5. Run `run --detach`, then monitor `events --follow --since SEQ`. Persist the\n   last handled sequence; replay after reconnect. An unfilled or rejected order\n   remains incomplete: do not claim the requested trade succeeded. A fill updates the trading\n   plan, an error follows the catalog below, and expiry warnings prompt rotation\n   using external master-wallet approval.\n\n## Completion and approval boundaries\n\nRead this skill and query schemas before acting. Keep a progress record with the\nnetwork, current stage, deposit IDs, last event sequence and order cloid/oid;\nrecord public IDs only. Missing selected-signer settings, a wallet signature,\nfunding route or settled balance is a blocked stage. Report the exact next action\nwithout requesting any secret in chat or moving to the next stage. Repeat `init`\nto resume persisted approvals rather than creating another agent. Approval and\nrevoke payloads include `expiresAt` and are regenerated after 24 hours, or when\nHyperliquid rejects the nonce; sign the regenerated payload. An `ok:true`\ntransport envelope does not imply exchange acceptance. Every live or paper\n`order` carries a `cloid` (generated when omitted) on the success and on the\nerror. A mutation timeout or disconnect is `NETWORK_ERROR` with `retryable:\nfalse` and `details.outcome: "unknown"`. Retry that same `intentId` or `cloid`;\nthe CLI reuses the cloid and will not place a second order. Do not mint a new\ncloid for the same intent.\n\nFor EOA rotation, the user sets a new local key and supplies only its reference\nwith `rotate --eoa-key-ref env:NEW_EOA_KEY`. For either signer, verify\n`swapped:true` before asking the external wallet to sign old agent revocation. Require `oldRevoked:true` before claiming rotation complete.\n`revoke` immediately disables local signing; only `exchangeRevoked:true` confirms\nthat the signed exchange revocation was submitted. Inspect `status` to verify the\nagent is absent from exchange approvals. Cancel outstanding orders before final\nrevocation, and report any cancellation or cleanup failure explicitly.\n\n## Commands and example envelopes\n\nExamples show representative `data`, not live balances or service promises.\nFull inputs/outputs are discoverable with `schema`; amounts/prices are strings.\n\n| Input | Example output |\n| --- | --- |\n| `--help` | `{"ok":true,"data":{"commands":[{"name":"status","description":"Read account status"}],"globalFlags":["--json","--config","--network","--pretty"]}}` |\n| `schema order` | `{"ok":true,"data":{"input":{"type":"object"},"output":{"oneOf":[]}}}` (actual schemas include properties) |\n| `config get network` | `{"ok":true,"data":"testnet"}` |\n| `config set limits.maxLeverage 5` | `{"ok":true,"data":{"version":1,"limits":{"maxLeverage":5}}}` |\n| `config validate` | `{"ok":true,"data":{"valid":true,"version":1}}` |\n| `init --master-address 0x...` | `{"ok":true,"data":{"approved":false,"requiresSignature":true,"approvals":{"agent":{"typedData":{}}},"qrAscii":"..."}}` |\n| `fund --amount 10 --no-qr` | `{"ok":true,"data":{"depositId":"...","depositAddress":"0x...","expectedReceived":"100000000","builderFeeRate":"0%","builderAddress":"0x71b09A08257078A4d642F7Dd7315e656c837329a","state":"awaiting_funds","qrAscii":null}}` |\n| `deposit --deposit-id ID` | `{"ok":true,"data":{"depositId":"ID","steps":[{"id":"step:0","requiresSignature":true,"payload":{}}]}}` |\n| `deposit --deposit-id ID --step-id step:0 --signature 0x...` | `{"ok":true,"data":{"depositId":"ID","steps":[]}}` |\n| `status` | `{"ok":true,"data":{"balance":{"accountValue":"100"},"agent":{"approved":true,"daysRemaining":"179"},"deposits":[],"policy":{"id":"...","version":"2"},"runner":{"pid":"123"}}}` |\n| `balance` | `{"ok":true,"data":{"accountValue":"100","accountValueUnits":"10000000000","withdrawable":"96","marginUsed":"4"}}` |\n| `market --coin BTC` | `{"ok":true,"data":{"coin":"BTC","asset":"0","szDecimals":"5","maxLeverage":"40","mid":"20000"}}` |\n| `positions` | `{"ok":true,"data":[{"coin":"BTC","size":"0.001","entryPrice":"20000","leverage":"5","marginMode":"cross"}]}` |\n| `orders` | `{"ok":true,"data":[{"coin":"BTC","oid":"123","sz":"0.001","limitPx":"20000","side":"B"}]}` |\n| `order --json \'{"coin":"BTC","side":"buy","size":"0.001","price":"20000","tif":"Gtc","cloid":"0x11111111111111111111111111111111"}\'` | `{"ok":true,"data":{"result":{"status":"ok","response":{"data":{"statuses":[{"resting":{"oid":123}}]}}},"builderFeeRate":"0%","builderAddress":"0x71b09A08257078A4d642F7Dd7315e656c837329a","cloid":"0x..."}}` |\n| `order --json \'{"coin":"BTC","side":"sell","size":"0.001","type":"market","slippage":0.01,"reduceOnly":true}\'` | `{"ok":true,"data":{"result":{"status":"ok","response":{"data":{"statuses":[{"filled":{"oid":123}}]}}}}}` |\n| `cancel --oid 123` or `cancel --all` | `{"ok":true,"data":{"cancelled":["123"],"result":{"status":"ok"}}}` |\n| `modify --json \'{"modifications":[{"oid":123,"price":"20100","size":"0.001"}]}\'` | `{"ok":true,"data":{"status":"ok"}}` |\n| `leverage --coin BTC --leverage 5 --mode isolated` | `{"ok":true,"data":{"status":"ok"}}` |\n| `run --detach` | `{"ok":true,"data":{"pid":123,"startedAt":1700000000000,"network":"testnet"}}` |\n| `events --since 12 --types \'["fill"]\'` | `{"ok":true,"data":[{"seq":13,"timestamp":"2026-01-01T00:00:00.000Z","type":"fill","data":{"tid":1}}]}` |\n| `events --follow` | `{"seq":13,"timestamp":"2026-01-01T00:00:00.000Z","type":"fill","data":{"tid":1}}` (one line per event) |\n| `logs --follow --level warn` | `{"level":"warn","requestId":"...","message":"Risk rejected","time":"..."}` (JSON lines) |\n| `paper reset --yes` | `{"ok":true,"data":{"paper":true,"mode":"paper","reset":true,"startingBalance":"10000"},"mode":"paper","paper":true}` |\n| `paper summary` | `{"ok":true,"data":{"paper":true,"mode":"paper","equity":"10000","netPnl":"0","feesPaid":"0","fundingPaid":"0","trades":0,"positions":[]}}` |\n| `order --paper --json \'{"coin":"BTC","side":"buy","size":"0.001","type":"market"}\'` | `{"ok":true,"data":{"result":{"status":"ok","response":{"data":{"statuses":[{"filled":{"oid":1,"totalSz":"0.001","avgPx":"20000","status":"filled"}}]}}},"builderFeeRate":"0%","builderAddress":"0x71b09A08257078A4d642F7Dd7315e656c837329a","cloid":"0x22222222222222222222222222222222"},"mode":"paper","paper":true}` |\n| `run --paper --detach` | `{"ok":true,"data":{"pid":123,"startedAt":1700000000000,"network":"mainnet","paper":true}}` |\n| `rotate` then `rotate --signature 0x...` | `{"ok":true,"data":{"oldAgent":"0x...","newAgent":"0x...","swapped":true,"oldRevoked":false,"revokeApproval":{}}}` |\n| `rotate --revoke-signature 0x...` | `{"ok":true,"data":{"swapped":true,"oldRevoked":true}}` |\n| `revoke --cancel-orders` | `{"ok":true,"data":{"locallyRevoked":true,"exchangeRevoked":false,"requiresSignature":true,"approval":{}}}` |\n| `revoke --signature 0x...` | `{"ok":true,"data":{"locallyRevoked":true,"exchangeRevoked":true}}` |\n| `audit --intent ID` | `{"ok":true,"data":[{"intentId":"ID","stage":"decision","data":{"allowed":true},"previousHash":"...","hash":"..."}]}` |\n| `skill install --target codex` | `{"ok":true,"data":{"target":"codex","path":".../agent-cli/SKILL.md","version":"0.4.0"}}` |\n\nBefore an order, query `market --coin BTC` for `mid`, `szDecimals`, asset and\nmarket leverage ceiling. Compute size/notional with decimal strings/bigints,\nusing the user-approved limit or the bounded IOC execution price. A valid schema\nalone does not establish that an order is tradable or within the budget.\n\nUse `--intent-id ID --intent "reason"` on trading actions to connect the user\'s\nreasoning to the audit. The CLI binds that intent to one cloid. Risk checks use\nthe account leverage Hyperliquid will apply and fail closed if it cannot be\nread. Live and paper mutations are serialized per account. `--live` and\n`--paper` select the mode explicitly; a running runner rejects a command whose\nmode does not match the runner or the saved config (`CONFIG_INVALID`) until the\nrunner is restarted. Trading, rotate, and revoke reject a network other than\n`approvedNetwork`.\nFor TP/SL use `type:"tp"|"sl"` and `triggerPrice` with size/price/reduceOnly;\nmarket orders use an explicit slippage-bounded IOC, not an unbounded market order.\n\n## Error recovery\n\n| Code | Action |\n| --- | --- |\n| RATE_LIMIT, NETWORK_ERROR | At most 3 read retries with exponential backoff. A mutation with `details.outcome` `"unknown"` is not retryable: retry the same `intentId` or `cloid` only, which the CLI reconciles. Stop if that result is still unknown |\n| NONCE_COLLISION | Retry using a newly issued nonce. A stale approval nonce is not retryable; sign the regenerated payload. A lock held by a live process is `INTERNAL` and is not retryable |\n| DEPOSIT_PENDING | Poll status until settled, expired, or abandoned. `cancel` and reduce-only orders still run. `deposit --abandon` stops a quote you will not fund |\n| RUNNER_NOT_RUNNING | Start runner or use configured direct fallback |\n| INSUFFICIENT_MARGIN | Reduce exposure or request authorized funding |\n| POLICY_REJECTED | Stop and revise intent within limits; do not bypass policy |\n| AGENT_EXPIRED | Rotate with master-wallet approval |\n| AGENT_NOT_APPROVED | Complete init/approval or explain revocation |\n| INVALID_SIZE, INVALID_PRICE | Correct input using market precision |\n| UNKNOWN_MARKET | Refresh metadata; use an allowed market |\n| ORDER_NOT_FOUND | Refresh orders before changing intent. An unknown or expired agent is `AGENT_NOT_APPROVED` or `AGENT_EXPIRED`, not this code |\n| CONFIG_INVALID | Correct configuration/input; never insert secrets |\n| UPSTREAM_ERROR, INTERNAL | Stop, inspect redacted details/logs and report failure |\n\n## Gotchas\n\nHyperCore perps USDC uses **8 decimals**; EVM USDC uses **6**. The quote\'s origin\ndecimals must match `originDecimals` or `fund` returns `CONFIG_INVALID`. Preserve\nstrings and bigints. Some deposits require **two distinct signatures**; resume\nstored steps rather than restarting the route. Agent expiry is at most **180 days**.\nFills in `events.jsonl` are delivered once per exchange `tid`, including\nfills that happen while the runner is down; dedupe by `tid` as well as `seq`.\nNever\nask for, paste, log or import a master private key or seed. EOA agent keys are\naccepted only through user-configured local references, never command input.\nThe agent is trade-only; local limits include markets, size/notional, leverage,\ndaily loss and open orders \u2014 in paper mode these limits are enforced exactly the\nsame way. Privy sees an L1 action hash, so it cannot independently inspect\nnotional/action contents; EOA agents have no remote Privy policy. Hyperliquid\nagent permissions and local checks enforce those boundaries for both signers. State is always `~/.bloxwap`, env prefix `BLOXWAP_`; paper\nstate is `~/.bloxwap/paper/` and is never read by live commands (or vice\nversa). Envelopes and events always state `mode`/`paper`.\n\n\n## Verification boundaries\n\nOffline skill tests validate the documented command examples against CLI schemas.\nMocked lifecycle tests exercise resumable approvals, pending funding, events\nand failure handling. These checks do **not** prove a live agent or\nexchange run. The nightly testnet lifecycle uses only a company-owned disposable\nCI master account and separate test Privy app, live Privy and Hyperliquid\napprovals/revocation, and explicitly mocked Relay plus mocked Hyperliquid orders\nthat never reach the exchange. The dedicated master account still needs a positive\ntest USDC balance because live approvals require prior test collateral.\nThe same harness supports a caller-controlled external wallet approval adapter\non a clean QA runner; its private key stays in that wallet. It never transfers\nreal funds. Missing CI credentials fail the job; a skipped or\nmocked test must never be reported as live validation. Record the workflow run,\ncommit, lifecycle report, event and audit artifacts before claiming a testnet pass.\nSee `docs/agent-workflow.md` and `docs/testnet.md` in the repository for setup.\n';
+
+// src/commands/skill.ts
+async function installSkill(target, options = {}) {
+  const home = options.home ?? homedir();
+  const root = target === "codex" ? options.codexHome ?? process.env.CODEX_HOME ?? join7(home, ".codex") : join7(home, ".claude");
+  const path = join7(root, "skills", "agent-cli", "SKILL.md");
+  try {
+    const existing = await readFile6(path, "utf8");
+    if (existing === skillContent)
+      return { target, path, version: cliVersion, changed: false };
+    if (!options.force)
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Skill already exists with different content; use --force to replace"
+      );
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  await atomicWrite(path, skillContent);
+  return { target, path, version: cliVersion, changed: true };
+}
+register("skill", {
+  description: "Install packaged version-matched skill for Claude Code or Codex",
+  schema: z16.object({
+    args: z16.array(z16.string()).default(["install"]),
+    target: z16.enum(["claude", "codex"]).default("codex"),
+    force: z16.boolean().default(false)
+  }),
+  execute: async (input) => {
+    if (input.args[0] !== "install")
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Use skill install --target claude|codex"
+      );
+    return installSkill(input.target, {
+      force: input.force
+    });
+  }
+});
+
+// src/commands/market.ts
+import { z as z17 } from "zod";
+register("market", {
+  description: "Discover market asset, precision, leverage ceiling and current mid",
+  schema: z17.object({ coin: z17.string() }),
+  execute: async (input, context) => {
+    const config = await commandConfig(context);
+    try {
+      const [market, mids] = await Promise.all([
+        createClients(config.network).meta.lookup(input.coin),
+        hlInfo(config.network, "allMids")
+      ]);
+      const mid = mids[market.name];
+      if (!mid)
+        throw new AgentCliError("UNKNOWN_MARKET", "Market has no mid price");
+      return {
+        coin: market.name,
+        asset: String(market.asset),
+        szDecimals: String(market.szDecimals),
+        maxLeverage: String(market.maxLeverage),
+        mid
+      };
+    } catch (error) {
+      throw mapHyperliquidError(error);
+    }
+  }
+});
+
+// src/commands/paper.ts
+import { z as z18 } from "zod";
+async function paperSummary(store, data = paperData()) {
+  const [state, marks] = await Promise.all([store.load(), data.marks()]);
+  rolloverDay(state, marks, Date.now());
+  const maxLeverageOf = async (coin) => data.maxLeverageOf(coin);
+  const resolved = /* @__PURE__ */ new Map();
+  for (const coin of new Set(state.positions.map((p) => p.coin)))
+    resolved.set(coin, await maxLeverageOf(coin));
+  const equity = accountEquity(state, marks);
+  const account = paperAccountState(state, marks, (coin) => resolved.get(coin) ?? 1);
+  const unrealized = account.assetPositions.reduce(
+    (sum, p) => sum + parseUsdc(p.position.unrealizedPnl, 18),
+    0n
+  );
+  return {
+    paper: true,
+    mode: "paper",
+    dataNetwork: paperDataNetwork,
+    startingBalance: state.startingBalance,
+    balance: state.balance,
+    equity: formatUsdc(equity, 18),
+    netPnl: formatUsdc(equity - parseUsdc(state.startingBalance, 18), 18),
+    realizedPnl: state.realizedPnl,
+    unrealizedPnl: formatUsdc(unrealized, 18),
+    feesPaid: state.feesPaid,
+    fundingPaid: state.fundingPaid,
+    trades: state.trades.length,
+    liquidations: state.liquidations,
+    openOrders: state.orders.length,
+    positions: account.assetPositions.map(({ position: p }) => ({
+      coin: p.coin,
+      size: p.szi,
+      entryPrice: p.entryPx,
+      markPrice: marks[p.coin] ?? null,
+      unrealizedPnl: p.unrealizedPnl,
+      liquidationPrice: liquidationPx(
+        state.positions.find((position) => position.coin === p.coin),
+        resolved.get(p.coin) ?? 1
+      ),
+      leverage: String(p.leverage.value),
+      marginMode: p.leverage.type
+    }))
+  };
+}
+register("paper", {
+  description: "Reset or summarize the local paper trading account",
+  schema: z18.object({
+    args: z18.array(z18.string()).default([]),
+    yes: z18.boolean().default(false),
+    balance: z18.number().positive().optional()
+  }),
+  execute: async (input, context) => {
+    const [action = "summary"] = input.args;
+    const config = await loadConfig(context.configPath);
+    if (context.paper !== void 0)
+      config.mode = context.paper ? "paper" : "live";
+    const store = new PaperStore();
+    if (action === "reset") {
+      if (!input.yes)
+        throw new AgentCliError(
+          "CONFIG_INVALID",
+          "paper reset clears all paper state; re-run with --yes to confirm"
+        );
+      const starting = input.balance ?? config.paper.startingBalance;
+      await store.reset(starting);
+      await atomicWrite(paperEvents.path, "");
+      return {
+        paper: true,
+        mode: "paper",
+        reset: true,
+        startingBalance: String(starting)
+      };
+    }
+    if (action !== "summary")
+      throw new AgentCliError(
+        "CONFIG_INVALID",
+        "Use paper summary or paper reset"
+      );
+    return paperSummary(store);
+  }
+});
+
+// src/cli.ts
+setRouting(routeToRunner);
+try {
+  let stdin = "";
+  if (!process.stdin.isTTY)
+    for await (const chunk of process.stdin) {
+      stdin += String(chunk);
+      if (Buffer.byteLength(stdin) > 1048576)
+        throw new AgentCliError("CONFIG_INVALID", "JSON input exceeds 1 MiB");
+    }
+  const result = await dispatch(process.argv.slice(2), stdin);
+  if (!result.context.streaming || !result.body.ok)
+    process.stdout.write(
+      JSON.stringify(result.body, null, result.context.pretty ? 2 : void 0) + "\n"
+    );
+  process.exitCode = result.exitCode;
+} catch (error) {
+  const normalized = normalizeError(error);
+  process.stdout.write(JSON.stringify(normalized.toJSON()) + "\n");
+  process.exitCode = normalized.exitCode;
+}