zk-agent-cli 0.1.0-rc.3 → 0.1.0-rc.4

package/README.md

@@ -34,6 +34,18 @@ What each step is doing:
 - `workflow pay` is the flagship zkSync-native AA native-send path
 - `suite` is the packaged surface
 
+The packaged default story is payment-first: send native value now, stay on
+the approval-based pay path when fee-token/default state matters, and recover
+funding only when the workflow says the write path is blocked.
+
+The first Agent Pay platform primitive now exists as a local-first payment
+request surface:
+
+```bash
+zk-agent payment create --wallet main --to <address> --amount <amount>
+zk-agent payment list
+```
+
 If readiness is unclear before you choose a fix, use:
 
 ```bash
@@ -116,6 +128,7 @@ ZK_AGENT_STORAGE_DIR=
   `zk-agent wallet next --name <wallet>`: wallet-scoped repair and readiness
 - `zk-agent workflow ...`: explicit workflow planning, persistence, status, and
   resume questions
+- `zk-agent payment ...`: local-first payment request capture and settlement-state tracking for the Agent Pay platform layer
 - `zk-agent suite`: the packaged post-flagship catalog once wallet readiness is
   no longer the blocker
 
@@ -225,6 +238,9 @@ Current `suite` operator journeys:
 - `unstick a write`
 - `recover remote approval`
 
+If you only need one default starting point inside `suite`, start with
+`send value now`.
+
 Use `--wallet <name>` or `--chain <chain>` when the returned suite commands
 should stay on a non-default wallet or chain.
 

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command13, CommanderError } from "commander";
+import { Command as Command14, CommanderError } from "commander";
 import { config as loadEnv } from "dotenv";
 
 // src/commands/operations.ts
@@ -79,6 +79,9 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 
+// ../agent-core/src/wallet-session.ts
+import { createHash } from "node:crypto";
+
 // ../agent-session-protocol/src/constants.ts
 var PROTOCOL_VERSION = "zk-agent-session-v1";
 
@@ -239,6 +242,10 @@ function buildApprovedSessionPayload(input) {
 function isHexPrivateKey(value) {
   return /^0x[a-fA-F0-9]{64}$/.test(value);
 }
+function deriveStableWalletId(wallet) {
+  const seed = `${wallet.walletAddress.trim().toLowerCase()}:${wallet.chainId}:${wallet.createdAt.trim()}`;
+  return `wal_${createHash("sha256").update(seed).digest("hex").slice(0, 24)}`;
+}
 function deriveLocalExecutionSignerAddress(privateKey) {
   if (!privateKey || !isHexPrivateKey(privateKey)) return void 0;
   try {
@@ -263,15 +270,25 @@ function resolveLocalExecutionPrivateKey(wallet) {
 function migrateWalletSessionRecord(wallet) {
   const legacyPrivateKey = wallet.sessionPayload?.sessionPrivateKey;
   const existingAuthority = wallet.localExecutionAuthority;
+  const walletId = wallet.walletId || deriveStableWalletId(wallet);
   if (!existingAuthority && !legacyPrivateKey) {
-    return wallet;
+    if (wallet.walletId === walletId) return wallet;
+    return {
+      ...wallet,
+      walletId
+    };
   }
   const privateKey = existingAuthority?.privateKey || legacyPrivateKey;
   if (!privateKey) {
-    return wallet;
+    if (wallet.walletId === walletId) return wallet;
+    return {
+      ...wallet,
+      walletId
+    };
   }
   return {
     ...wallet,
+    walletId,
     localExecutionAuthority: {
       privateKey,
       signerAddress: existingAuthority?.signerAddress || deriveLocalExecutionSignerAddress(privateKey),
@@ -375,6 +392,33 @@ function readEncryptedJson(filePath) {
 function storageDir() {
   return ensureStorageDir();
 }
+function ensureStorageCollectionDir(collectionName) {
+  const storageDirectory = ensureStorageDir();
+  const collectionDirectory = path.join(storageDirectory, collectionName);
+  if (!fs.existsSync(collectionDirectory)) {
+    fs.mkdirSync(collectionDirectory, { recursive: true, mode: 448 });
+  }
+  return collectionDirectory;
+}
+async function saveEncryptedStorageRecord(collectionName, recordId, value) {
+  const collectionDirectory = ensureStorageCollectionDir(collectionName);
+  writeEncryptedJson(path.join(collectionDirectory, `${recordId}.json`), value);
+}
+async function loadEncryptedStorageRecord(collectionName, recordId) {
+  const filePath = storagePath(collectionName, `${recordId}.json`);
+  if (!fs.existsSync(filePath)) return null;
+  return readEncryptedJson(filePath);
+}
+async function listEncryptedStorageRecordIds(collectionName) {
+  const collectionDirectory = ensureStorageCollectionDir(collectionName);
+  return fs.readdirSync(collectionDirectory).filter((entry) => entry.endsWith(".json")).map((entry) => entry.replace(/\.json$/, ""));
+}
+async function deleteEncryptedStorageRecord(collectionName, recordId) {
+  const filePath = storagePath(collectionName, `${recordId}.json`);
+  if (!fs.existsSync(filePath)) return false;
+  fs.unlinkSync(filePath);
+  return true;
+}
 async function saveProjectConfig(config) {
   const storageDirectory = ensureStorageDir();
   writeJson(path.join(storageDirectory, "config.json"), config);
@@ -385,64 +429,42 @@ async function loadProjectConfig() {
   return readJson(filePath);
 }
 async function saveWalletSession(record) {
-  const storageDirectory = ensureStorageDir();
-  writeEncryptedJson(
-    path.join(storageDirectory, "wallets", `${record.walletName}.json`),
-    migrateWalletSessionRecord(record)
-  );
+  await saveEncryptedStorageRecord("wallets", record.walletName, migrateWalletSessionRecord(record));
 }
 async function loadWalletSession(walletName) {
-  const filePath = storagePath("wallets", `${walletName}.json`);
-  if (!fs.existsSync(filePath)) return null;
-  return migrateWalletSessionRecord(readEncryptedJson(filePath));
+  const record = await loadEncryptedStorageRecord("wallets", walletName);
+  return record ? migrateWalletSessionRecord(record) : null;
 }
 async function listWalletNames() {
-  const storageDirectory = ensureStorageDir();
-  return fs.readdirSync(path.join(storageDirectory, "wallets")).filter((entry) => entry.endsWith(".json")).map((entry) => entry.replace(/\.json$/, ""));
+  return listEncryptedStorageRecordIds("wallets");
 }
 async function listWalletRequestIds() {
   const storageDirectory = ensureStorageDir();
   return fs.readdirSync(path.join(storageDirectory, "requests")).filter((entry) => entry.endsWith(".json")).map((entry) => entry.replace(/\.json$/, ""));
 }
 async function deleteWalletSession(walletName) {
-  const filePath = storagePath("wallets", `${walletName}.json`);
-  if (!fs.existsSync(filePath)) return false;
-  fs.unlinkSync(filePath);
-  return true;
+  return deleteEncryptedStorageRecord("wallets", walletName);
 }
 async function saveWalletRequest(record) {
-  const storageDirectory = ensureStorageDir();
-  writeEncryptedJson(path.join(storageDirectory, "requests", `${record.requestId}.json`), record);
+  await saveEncryptedStorageRecord("requests", record.requestId, record);
 }
 async function loadWalletRequest(requestId) {
-  const filePath = storagePath("requests", `${requestId}.json`);
-  if (!fs.existsSync(filePath)) return null;
-  return readEncryptedJson(filePath);
+  return loadEncryptedStorageRecord("requests", requestId);
 }
 async function deleteWalletRequest(requestId) {
-  const filePath = storagePath("requests", `${requestId}.json`);
-  if (!fs.existsSync(filePath)) return false;
-  fs.unlinkSync(filePath);
-  return true;
+  return deleteEncryptedStorageRecord("requests", requestId);
 }
 async function saveWorkflowCheckpoint(record) {
-  const storageDirectory = ensureStorageDir();
-  writeEncryptedJson(path.join(storageDirectory, "workflows", `${record.requestId}.json`), record);
+  await saveEncryptedStorageRecord("workflows", record.requestId, record);
 }
 async function loadWorkflowCheckpoint(requestId) {
-  const filePath = storagePath("workflows", `${requestId}.json`);
-  if (!fs.existsSync(filePath)) return null;
-  return readEncryptedJson(filePath);
+  return loadEncryptedStorageRecord("workflows", requestId);
 }
 async function listWorkflowCheckpointIds() {
-  const storageDirectory = ensureStorageDir();
-  return fs.readdirSync(path.join(storageDirectory, "workflows")).filter((entry) => entry.endsWith(".json")).map((entry) => entry.replace(/\.json$/, ""));
+  return listEncryptedStorageRecordIds("workflows");
 }
 async function deleteWorkflowCheckpoint(requestId) {
-  const filePath = storagePath("workflows", `${requestId}.json`);
-  if (!fs.existsSync(filePath)) return false;
-  fs.unlinkSync(filePath);
-  return true;
+  return deleteEncryptedStorageRecord("workflows", requestId);
 }
 async function renameWalletSession(walletName, nextWalletName) {
   const storageDirectory = ensureStorageDir();
@@ -461,7 +483,7 @@ async function renameWalletSession(walletName, nextWalletName) {
   if (fs.existsSync(targetFilePath)) {
     throw new Error(`Wallet already exists: ${targetName}`);
   }
-  const wallet = readEncryptedJson(currentFilePath);
+  const wallet = migrateWalletSessionRecord(readEncryptedJson(currentFilePath));
   wallet.walletName = targetName;
   writeEncryptedJson(targetFilePath, wallet);
   fs.unlinkSync(currentFilePath);
@@ -8000,6 +8022,37 @@ function buildWorkflowPayRecommendedCommand(walletName, paymasterMode) {
   const command = `zk-agent workflow pay --wallet ${walletName} --to <address> --amount <amount>`;
   return appendPaymasterMode(command, paymasterMode);
 }
+function buildSendTokenRecommendedCommand(input) {
+  let command = `zk-agent send-token --wallet ${input.walletName}`;
+  command += ` --to ${input.to || "<address>"}`;
+  command += ` --amount ${input.amount || "<amount>"}`;
+  if (input.symbol) {
+    command += ` --symbol ${input.symbol}`;
+  }
+  if (input.tokenAddress) {
+    command += ` --token ${input.tokenAddress}`;
+  }
+  if (input.decimals !== void 0) {
+    command += ` --decimals ${input.decimals}`;
+  }
+  return appendPaymasterMode(command, input.paymasterMode);
+}
+function buildPaymentListRecommendedCommand() {
+  return "zk-agent payment list";
+}
+function buildPaymentShowRecommendedCommand(requestId) {
+  return `zk-agent payment show --request-id ${requestId}`;
+}
+function buildPaymentSetStatusRecommendedCommand(requestId, status, txHash) {
+  let command = `zk-agent payment set-status --request-id ${requestId} --status ${status}`;
+  if (txHash) {
+    command += ` --tx-hash ${txHash}`;
+  }
+  return command;
+}
+function buildPaymentRemoveRecommendedCommand(requestId) {
+  return `zk-agent payment remove --request-id ${requestId}`;
+}
 function buildWorkflowFundRecommendedCommand(walletName) {
   return `zk-agent workflow fund --wallet ${walletName}`;
 }
@@ -12838,8 +12891,615 @@ function createDefaultsCommand() {
   });
 }
 
-// src/commands/resolve-token.ts
+// src/commands/payment.ts
+import { randomBytes as randomBytes5 } from "node:crypto";
 import { Command as Command7 } from "commander";
+
+// ../agent-pay/src/execution-plan.ts
+function buildPaymentExecutionPlan(record) {
+  return {
+    action: record.asset.kind === "native" ? "native-transfer" : "erc20-transfer",
+    surface: record.executionPreference.surface,
+    walletId: record.walletId,
+    walletName: record.walletName,
+    chain: record.chain,
+    chainId: record.chainId,
+    paymasterMode: record.executionPreference.paymasterMode,
+    payeeAddress: record.payee.address,
+    asset: record.asset
+  };
+}
+
+// ../agent-pay/src/payment-request.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+var PAYMENT_REQUEST_STATUS_TRANSITIONS = {
+  draft: ["draft", "ready", "cancelled"],
+  ready: ["draft", "ready", "paid", "cancelled"],
+  paid: ["paid"],
+  cancelled: ["cancelled"]
+};
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function createPaymentHistoryEventId() {
+  return `payevt-${randomBytes4(4).toString("hex")}`;
+}
+function normalizeOptionalString4(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function normalizeMetadata2(metadata) {
+  if (!metadata) return {};
+  const normalized = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    const normalizedKey = key.trim();
+    const normalizedValue = value.trim();
+    if (!normalizedKey || !normalizedValue) continue;
+    normalized[normalizedKey] = normalizedValue;
+  }
+  return normalized;
+}
+function normalizePaymentAsset(asset) {
+  const amount = asset.amount.trim();
+  if (!amount) {
+    throw new AgentError("PAYMENT_AMOUNT_REQUIRED", "Payment amount is required.");
+  }
+  if (asset.kind === "native") {
+    return {
+      kind: "native",
+      amount,
+      symbol: normalizeOptionalString4(asset.symbol)
+    };
+  }
+  const tokenAddress = asset.tokenAddress?.trim();
+  if (!tokenAddress) {
+    throw new AgentError(
+      "PAYMENT_TOKEN_REQUIRED",
+      "ERC-20 payment requests require a token address."
+    );
+  }
+  if (!Number.isInteger(asset.decimals) || Number(asset.decimals) < 0) {
+    throw new AgentError(
+      "PAYMENT_TOKEN_DECIMALS_REQUIRED",
+      "ERC-20 payment requests require non-negative token decimals."
+    );
+  }
+  return {
+    kind: "erc20",
+    amount,
+    tokenAddress,
+    decimals: Number(asset.decimals),
+    symbol: normalizeOptionalString4(asset.symbol)
+  };
+}
+function inferExecutionSurface(asset) {
+  return asset.kind === "native" ? "workflow-pay" : "send-token";
+}
+function createPaymentHistoryEvent(input) {
+  return {
+    eventId: createPaymentHistoryEventId(),
+    type: input.type,
+    at: input.at,
+    status: input.status,
+    previousStatus: input.previousStatus,
+    txHash: normalizeOptionalString4(input.txHash),
+    note: normalizeOptionalString4(input.note)
+  };
+}
+function buildLegacyPaymentHistory(record) {
+  return [
+    {
+      eventId: `payevt-${record.requestId}-legacy-created`,
+      type: "created",
+      at: record.createdAt,
+      status: record.settlement.status,
+      txHash: record.settlement.txHash,
+      note: record.settlement.note
+    }
+  ];
+}
+function migratePaymentRequestRecord(record) {
+  return {
+    ...record,
+    history: Array.isArray(record.history) && record.history.length > 0 ? record.history.map((event) => ({
+      ...event,
+      txHash: normalizeOptionalString4(event.txHash),
+      note: normalizeOptionalString4(event.note)
+    })) : buildLegacyPaymentHistory(record)
+  };
+}
+function createPaymentRequestRecord(input) {
+  const timestamp = nowIso2();
+  const payeeAddress = input.payeeAddress.trim();
+  if (!payeeAddress) {
+    throw new AgentError("PAYMENT_PAYEE_REQUIRED", "Payment payee address is required.");
+  }
+  const asset = normalizePaymentAsset(input.asset);
+  const status = input.status ?? "ready";
+  return {
+    format: "zk-agent-payment-request",
+    version: 1,
+    requestId: input.requestId.trim(),
+    walletId: input.walletId.trim(),
+    walletName: input.walletName.trim(),
+    walletAddress: input.walletAddress.trim(),
+    chain: input.chain.trim(),
+    chainId: input.chainId,
+    payer: {
+      walletId: input.walletId.trim(),
+      walletName: input.walletName.trim(),
+      walletAddress: input.walletAddress.trim(),
+      name: normalizeOptionalString4(input.payerName)
+    },
+    payee: {
+      address: payeeAddress,
+      name: normalizeOptionalString4(input.payeeName)
+    },
+    asset,
+    description: normalizeOptionalString4(input.description),
+    memo: normalizeOptionalString4(input.memo),
+    metadata: normalizeMetadata2(input.metadata),
+    executionPreference: {
+      surface: inferExecutionSurface(asset),
+      paymasterMode: input.paymasterMode ?? "none"
+    },
+    settlement: {
+      status
+    },
+    history: [
+      createPaymentHistoryEvent({
+        type: "created",
+        at: timestamp,
+        status
+      })
+    ],
+    createdAt: timestamp,
+    updatedAt: timestamp
+  };
+}
+function applyPaymentRequestStatusUpdate(record, input) {
+  const nextStatus = input.status;
+  const allowedTransitions = PAYMENT_REQUEST_STATUS_TRANSITIONS[record.settlement.status];
+  if (!allowedTransitions.includes(nextStatus)) {
+    throw new AgentError(
+      "PAYMENT_STATUS_TRANSITION_INVALID",
+      `Cannot move payment request ${record.requestId} from ${record.settlement.status} to ${nextStatus}.`,
+      {
+        currentStatus: record.settlement.status,
+        nextStatus,
+        allowedTransitions
+      }
+    );
+  }
+  const timestamp = nowIso2();
+  const nextTxHash = normalizeOptionalString4(input.txHash);
+  const nextNote = normalizeOptionalString4(input.note);
+  return {
+    ...record,
+    updatedAt: timestamp,
+    settlement: {
+      status: nextStatus,
+      paidAt: nextStatus === "paid" ? timestamp : record.settlement.paidAt,
+      cancelledAt: nextStatus === "cancelled" ? timestamp : record.settlement.cancelledAt,
+      txHash: nextTxHash ?? record.settlement.txHash,
+      note: nextNote ?? record.settlement.note
+    },
+    history: [
+      ...record.history,
+      createPaymentHistoryEvent({
+        type: "status-updated",
+        at: timestamp,
+        status: nextStatus,
+        previousStatus: record.settlement.status,
+        txHash: nextTxHash,
+        note: nextNote
+      })
+    ]
+  };
+}
+
+// ../agent-pay/src/storage.ts
+var PAYMENT_REQUEST_COLLECTION = "payments";
+async function savePaymentRequest(record) {
+  await saveEncryptedStorageRecord(
+    PAYMENT_REQUEST_COLLECTION,
+    record.requestId,
+    migratePaymentRequestRecord(record)
+  );
+}
+async function loadPaymentRequest(requestId) {
+  const record = await loadEncryptedStorageRecord(
+    PAYMENT_REQUEST_COLLECTION,
+    requestId
+  );
+  return record ? migratePaymentRequestRecord(record) : null;
+}
+async function listPaymentRequestIds() {
+  return listEncryptedStorageRecordIds(PAYMENT_REQUEST_COLLECTION);
+}
+async function deletePaymentRequest(requestId) {
+  return deleteEncryptedStorageRecord(PAYMENT_REQUEST_COLLECTION, requestId);
+}
+async function renamePaymentRequestWalletReferences(options) {
+  const currentName = options.previousWalletName.trim();
+  const targetName = options.nextWalletName.trim();
+  const walletId = options.walletId?.trim();
+  if (!currentName) throw new Error("Current wallet name is required.");
+  if (!targetName) throw new Error("New wallet name is required.");
+  if (currentName === targetName) return [];
+  const updatedRequestIds = [];
+  for (const requestId of await listPaymentRequestIds()) {
+    const paymentRequest = await loadPaymentRequest(requestId);
+    if (!paymentRequest) continue;
+    const matchesWallet = walletId && paymentRequest.walletId ? paymentRequest.walletId === walletId : paymentRequest.walletName === currentName;
+    if (!matchesWallet) continue;
+    if (walletId) {
+      paymentRequest.walletId = walletId;
+      paymentRequest.payer.walletId = walletId;
+    }
+    paymentRequest.walletName = targetName;
+    paymentRequest.payer.walletName = targetName;
+    await savePaymentRequest(paymentRequest);
+    updatedRequestIds.push(requestId);
+  }
+  return updatedRequestIds;
+}
+
+// ../agent-pay/src/service.ts
+async function requirePaymentRequest(requestId) {
+  const record = await loadPaymentRequest(requestId);
+  if (!record) {
+    throw new AgentError(
+      "PAYMENT_REQUEST_NOT_FOUND",
+      `Payment request not found: ${requestId}`
+    );
+  }
+  return record;
+}
+async function createStoredPaymentRequest(input) {
+  const paymentRequest = createPaymentRequestRecord(input);
+  await savePaymentRequest(paymentRequest);
+  return {
+    paymentRequest,
+    executionPlan: buildPaymentExecutionPlan(paymentRequest)
+  };
+}
+async function getStoredPaymentRequest(requestId) {
+  const paymentRequest = await requirePaymentRequest(requestId);
+  return {
+    paymentRequest,
+    executionPlan: buildPaymentExecutionPlan(paymentRequest)
+  };
+}
+async function listStoredPaymentRequests(input = {}) {
+  const requestIds = await listPaymentRequestIds();
+  const requests = [];
+  for (const requestId of requestIds) {
+    const record = await loadPaymentRequest(requestId);
+    if (!record) continue;
+    if (input.walletName && record.walletName !== input.walletName) continue;
+    if (input.status && record.settlement.status !== input.status) continue;
+    requests.push(record);
+  }
+  return requests.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+}
+async function updateStoredPaymentRequestStatus(input) {
+  const paymentRequest = await requirePaymentRequest(input.requestId);
+  const updated = applyPaymentRequestStatusUpdate(paymentRequest, input);
+  await savePaymentRequest(updated);
+  return {
+    paymentRequest: updated,
+    executionPlan: buildPaymentExecutionPlan(updated)
+  };
+}
+async function removeStoredPaymentRequest(requestId) {
+  return deletePaymentRequest(requestId);
+}
+
+// src/commands/payment.ts
+function parseMetadataEntries2(entries) {
+  const metadata = {};
+  for (const entry of entries) {
+    const separatorIndex = entry.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex === entry.length - 1) {
+      throw new AgentError(
+        "PAYMENT_METADATA_INVALID",
+        `Invalid metadata entry: ${entry}. Use key=value.`
+      );
+    }
+    const key = entry.slice(0, separatorIndex).trim();
+    const value = entry.slice(separatorIndex + 1).trim();
+    if (!key || !value) {
+      throw new AgentError(
+        "PAYMENT_METADATA_INVALID",
+        `Invalid metadata entry: ${entry}. Use key=value.`
+      );
+    }
+    metadata[key] = value;
+  }
+  return metadata;
+}
+function resolvePaymentStatus(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return "ready";
+  if (normalized === "draft" || normalized === "ready" || normalized === "paid" || normalized === "cancelled") {
+    return normalized;
+  }
+  throw new AgentError(
+    "PAYMENT_STATUS_INVALID",
+    `Unsupported payment status: ${value}. Use draft, ready, paid, or cancelled.`
+  );
+}
+function resolvePaymasterMode2(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) return void 0;
+  if (normalized === "none" || normalized === "sponsored" || normalized === "approval-based") {
+    return normalized;
+  }
+  throw new AgentError(
+    "PAYMENT_PAYMASTER_MODE_INVALID",
+    `Unsupported paymaster mode: ${value}. Use none, sponsored, or approval-based.`
+  );
+}
+function buildPaymentRequestId(value) {
+  const trimmed = value?.trim();
+  if (trimmed) return trimmed;
+  return `payreq-${randomBytes5(4).toString("hex")}`;
+}
+function formatPaymentAsset(record) {
+  const symbol = record.asset.kind === "native" ? record.asset.symbol || "native" : record.asset.symbol || record.asset.tokenAddress || "erc20";
+  return `${record.asset.amount} ${symbol}`;
+}
+function buildPaymentExecuteCommand(plan) {
+  if (plan.asset.kind === "native") {
+    return buildWorkflowPayRecommendedCommand(
+      plan.walletName,
+      plan.paymasterMode
+    ).replace("--to <address>", `--to ${plan.payeeAddress}`).replace("--amount <amount>", `--amount ${plan.asset.amount}`);
+  }
+  return buildSendTokenRecommendedCommand({
+    walletName: plan.walletName,
+    to: plan.payeeAddress,
+    amount: plan.asset.amount,
+    tokenAddress: plan.asset.tokenAddress,
+    symbol: plan.asset.symbol,
+    decimals: plan.asset.decimals,
+    paymasterMode: plan.paymasterMode
+  });
+}
+function buildPaymentRecommendedCommands(record, executionPlan) {
+  return {
+    list: buildPaymentListRecommendedCommand(),
+    show: buildPaymentShowRecommendedCommand(record.requestId),
+    execute: buildPaymentExecuteCommand(executionPlan),
+    ...record.settlement.status === "draft" ? {
+      markReady: buildPaymentSetStatusRecommendedCommand(record.requestId, "ready"),
+      cancel: buildPaymentSetStatusRecommendedCommand(record.requestId, "cancelled")
+    } : {},
+    ...record.settlement.status === "ready" ? {
+      markDraft: buildPaymentSetStatusRecommendedCommand(record.requestId, "draft"),
+      markPaid: buildPaymentSetStatusRecommendedCommand(
+        record.requestId,
+        "paid",
+        "<tx-hash>"
+      ),
+      cancel: buildPaymentSetStatusRecommendedCommand(record.requestId, "cancelled")
+    } : {},
+    remove: buildPaymentRemoveRecommendedCommand(record.requestId)
+  };
+}
+function paymentRequestLines(record, executionPlan) {
+  const lines = [
+    ["request", record.requestId],
+    ["status", record.settlement.status],
+    ["wallet", record.walletName],
+    ["chain", `${record.chain} (${record.chainId})`],
+    ["payer", `${record.payer.name || record.payer.walletName} ${record.payer.walletAddress}`],
+    ["payee", `${record.payee.name || "payee"} ${record.payee.address}`],
+    ["asset", formatPaymentAsset(record)],
+    ["execution surface", record.executionPreference.surface],
+    ["paymaster mode", record.executionPreference.paymasterMode],
+    ["execute", buildPaymentExecuteCommand(executionPlan)],
+    ["show", buildPaymentShowRecommendedCommand(record.requestId)],
+    ["remove", buildPaymentRemoveRecommendedCommand(record.requestId)]
+  ];
+  if (record.description) lines.splice(7, 0, ["description", record.description]);
+  if (record.memo) lines.splice(record.description ? 8 : 7, 0, ["memo", record.memo]);
+  if (record.settlement.txHash) lines.push(["txHash", record.settlement.txHash]);
+  if (record.settlement.note) lines.push(["note", record.settlement.note]);
+  if (record.settlement.paidAt) lines.push(["paid at", record.settlement.paidAt]);
+  if (record.settlement.cancelledAt) lines.push(["cancelled at", record.settlement.cancelledAt]);
+  lines.push(["history events", String(record.history.length)]);
+  lines.push(["metadata keys", String(Object.keys(record.metadata).length)]);
+  return lines;
+}
+function buildPaymentExecutionPlanJson(plan) {
+  return {
+    ...plan,
+    command: buildPaymentExecuteCommand(plan)
+  };
+}
+function buildPaymentListSummary(record) {
+  return `${record.requestId} ${record.settlement.status} ${formatPaymentAsset(record)} -> ${record.payee.address} (${record.walletName})`;
+}
+function createPaymentCommand() {
+  const payment = new Command7("payment").description(
+    "Manage local-first Agent Pay request records separately from the execution-layer workflow and send commands"
+  );
+  payment.addHelpText(
+    "after",
+    [
+      "",
+      "  Payment request surface:",
+      "    Use this layer to capture payer/payee intent and local settlement state before or after execution.",
+      "    `workflow pay` and `send-token` still execute the transfer; `payment` stores the request record and status lifecycle.",
+      "",
+      "  First platform path:",
+      "    zk-agent payment create --wallet main --to <address> --amount <amount>",
+      "    zk-agent payment show --request-id <id>",
+      "    zk-agent payment set-status --request-id <id> --status paid --tx-hash <tx-hash>",
+      "",
+      "  ERC-20 request path:",
+      "    zk-agent payment create --wallet main --to <address> --amount <amount> --symbol USDC",
+      "",
+      "  Stored request management:",
+      "    zk-agent payment list",
+      "    zk-agent payment remove --request-id <id>"
+    ].join("\n")
+  );
+  payment.command("create").description("Create a local payment request record for native value or an ERC-20 transfer").option("--wallet <name>", "Stored payer wallet name", "main").requiredOption("--to <address>", "Payee address").requiredOption("--amount <value>", "Amount in human-readable units").option("--token <address>", "ERC-20 token contract address").option("--symbol <symbol>", "ERC-20 token symbol for registry-backed resolution").option("--decimals <value>", "ERC-20 token decimals when registry metadata is unavailable").option("--payee-name <name>", "Optional payee display name").option("--payer-name <name>", "Optional payer display name").option("--description <text>", "Short payment description").option("--memo <text>", "Optional memo or invoice reference").option("--metadata <key=value>", "Additional payment metadata", collectRepeatedString2, []).option("--paymaster-mode <mode>", "Optional execution preference: none, sponsored, or approval-based").option("--status <status>", "Initial local payment status: draft, ready, paid, or cancelled").option("--request-id <id>", "Optional explicit payment request id").action(async (options) => {
+    const wallet = await loadWalletSession(options.wallet);
+    if (!wallet) {
+      throw new AgentError("PAYMENT_WALLET_NOT_FOUND", `Wallet not found: ${options.wallet}`);
+    }
+    if (!wallet.walletId) {
+      throw new AgentError(
+        "WALLET_ID_MISSING",
+        `Wallet ${wallet.walletName} is missing a stable walletId. Re-save or reapprove the wallet session before creating a payment request.`
+      );
+    }
+    const paymasterMode = resolvePaymasterMode2(options.paymasterMode) ?? wallet.paymasterMode ?? "none";
+    const status = resolvePaymentStatus(options.status);
+    const metadata = parseMetadataEntries2(options.metadata);
+    const requestId = buildPaymentRequestId(options.requestId);
+    const hasTokenInput = Boolean(options.token?.trim() || options.symbol?.trim());
+    const asset = hasTokenInput ? await resolveRequiredTokenInput({
+      tokenAddress: options.token,
+      symbol: options.symbol,
+      decimals: options.decimals,
+      chain: wallet.chain,
+      tokenOptionLabel: "--token",
+      symbolOptionLabel: "--symbol",
+      decimalsOptionLabel: "--decimals"
+    }).then((token) => ({
+      kind: "erc20",
+      amount: options.amount,
+      tokenAddress: token.address,
+      decimals: token.decimals,
+      symbol: token.symbol
+    })) : {
+      kind: "native",
+      amount: options.amount
+    };
+    const result = await createStoredPaymentRequest({
+      requestId,
+      walletId: wallet.walletId,
+      walletName: wallet.walletName,
+      walletAddress: wallet.walletAddress,
+      chain: wallet.chain,
+      chainId: wallet.chainId,
+      payerName: options.payerName,
+      payeeAddress: options.to,
+      payeeName: options.payeeName,
+      asset,
+      description: options.description,
+      memo: options.memo,
+      metadata,
+      paymasterMode,
+      status
+    });
+    printResult(paymentRequestLines(result.paymentRequest, result.executionPlan), {
+      ok: true,
+      paymentRequest: result.paymentRequest,
+      executionPlan: buildPaymentExecutionPlanJson(result.executionPlan),
+      recommendedCommands: buildPaymentRecommendedCommands(
+        result.paymentRequest,
+        result.executionPlan
+      )
+    });
+  });
+  payment.command("list").description("List stored local payment request records").option("--wallet <name>", "Optional payer wallet filter").option("--status <status>", "Optional status filter: draft, ready, paid, or cancelled").action(async (options) => {
+    const statusFilter = options.status ? resolvePaymentStatus(options.status) : void 0;
+    const requests = await listStoredPaymentRequests({
+      walletName: options.wallet,
+      status: statusFilter
+    });
+    printResult(
+      requests.length > 0 ? requests.flatMap((record) => [
+        ["payment", buildPaymentListSummary(record)],
+        ["show", buildPaymentShowRecommendedCommand(record.requestId)]
+      ]) : [
+        ["status", "No stored payment requests"],
+        ["next", "zk-agent payment create --wallet main --to <address> --amount <amount>"]
+      ],
+      {
+        ok: true,
+        count: requests.length,
+        filters: {
+          walletName: options.wallet || null,
+          status: statusFilter || null
+        },
+        requests,
+        recommendedCommands: requests.length === 0 ? {
+          create: "zk-agent payment create --wallet main --to <address> --amount <amount>"
+        } : {
+          list: buildPaymentListRecommendedCommand()
+        }
+      }
+    );
+  });
+  payment.command("show").description("Show one stored payment request record").requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
+    const result = await getStoredPaymentRequest(options.requestId);
+    printResult(paymentRequestLines(result.paymentRequest, result.executionPlan), {
+      ok: true,
+      paymentRequest: result.paymentRequest,
+      executionPlan: buildPaymentExecutionPlanJson(result.executionPlan),
+      recommendedCommands: buildPaymentRecommendedCommands(
+        result.paymentRequest,
+        result.executionPlan
+      )
+    });
+  });
+  payment.command("set-status").description("Update the local settlement status of one stored payment request").requiredOption("--request-id <id>", "Stored payment request id").requiredOption("--status <status>", "Next status: draft, ready, paid, or cancelled").option("--tx-hash <hash>", "Optional settlement transaction hash").option("--note <text>", "Optional operator note for the status update").action(async (options) => {
+    const result = await updateStoredPaymentRequestStatus({
+      requestId: options.requestId,
+      status: resolvePaymentStatus(options.status),
+      txHash: options.txHash,
+      note: options.note
+    });
+    printResult(paymentRequestLines(result.paymentRequest, result.executionPlan), {
+      ok: true,
+      paymentRequest: result.paymentRequest,
+      executionPlan: buildPaymentExecutionPlanJson(result.executionPlan),
+      recommendedCommands: buildPaymentRecommendedCommands(
+        result.paymentRequest,
+        result.executionPlan
+      )
+    });
+  });
+  payment.command("remove").description("Delete one stored payment request record").requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
+    const removed = await removeStoredPaymentRequest(options.requestId);
+    if (!removed) {
+      throw new AgentError(
+        "PAYMENT_REQUEST_NOT_FOUND",
+        `Payment request not found: ${options.requestId}`
+      );
+    }
+    printResult(
+      [
+        ["status", "Payment request removed"],
+        ["request", options.requestId],
+        ["next", buildPaymentListRecommendedCommand()]
+      ],
+      {
+        ok: true,
+        requestId: options.requestId,
+        removed: true,
+        recommendedCommands: {
+          list: buildPaymentListRecommendedCommand(),
+          create: "zk-agent payment create --wallet main --to <address> --amount <amount>"
+        }
+      }
+    );
+  });
+  return payment;
+}
+function collectRepeatedString2(value, previous) {
+  return [...previous, value];
+}
+
+// src/commands/resolve-token.ts
+import { Command as Command8 } from "commander";
 function resolveResolveTokenCommandDeps(deps) {
   return {
     loadWallet: deps?.loadWallet ?? (async (walletName) => {
@@ -12897,7 +13557,7 @@ function buildResolveTokenDiscoverySummary(result) {
 }
 function createResolveTokenCommand(deps) {
   const resolvedDeps = resolveResolveTokenCommandDeps(deps);
-  return new Command7("resolve-token").description("Resolve a token symbol or address against the configured local-first token registry").addHelpText(
+  return new Command8("resolve-token").description("Resolve a token symbol or address against the configured local-first token registry").addHelpText(
     "after",
     [
       "",
@@ -13031,7 +13691,7 @@ function normalizeSource(value) {
 }
 
 // src/commands/suite.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/lib/operator-suite.ts
 function buildOperatorSuitePayload(options = {}) {
@@ -13219,6 +13879,13 @@ function buildOperatorSuitePayload(options = {}) {
       entryIds: ["hosted-approval-recovery"]
     }
   ];
+  const recommendedJourney = {
+    id: journeys[0].id,
+    title: journeys[0].title,
+    startCommand: journeys[0].startCommand,
+    surface: journeys[0].surface,
+    useWhen: journeys[0].useWhen
+  };
   return {
     ok: true,
     summary: {
@@ -13229,6 +13896,7 @@ function buildOperatorSuitePayload(options = {}) {
       stage: "wallet-ready-post-flagship",
       useWhen: "Use suite after wallet readiness when you want one packaged surface for flagship pay plus the current post-flagship discovery, paymaster, funding, and hosted recovery slices.",
       entryModes: ["local-first", "hosted-recovery"],
+      startHereJourneyId: recommendedJourney.id,
       journeyOrder: journeys.map((entry) => entry.id),
       surfaceOrder: ["workflow", "discovery", "relay"],
       categoryOrder: [flagship.category, ...slices.map((entry) => entry.category)],
@@ -13238,6 +13906,7 @@ function buildOperatorSuitePayload(options = {}) {
       nextAction: flagship.primaryCommand
     },
     ...preflight ? { preflight } : {},
+    recommendedJourney,
     journeys,
     surfaces,
     flagship,
@@ -13294,6 +13963,10 @@ function operatorSuiteLines(payload) {
     ["stage", payload.summary.stage],
     ["use when", payload.summary.useWhen],
     ["entry modes", payload.summary.entryModes.join(" -> ")],
+    ["start here journey", payload.summary.startHereJourneyId],
+    ["start here", payload.recommendedJourney.startCommand],
+    ["start here surface", payload.recommendedJourney.surface],
+    ["start here when", payload.recommendedJourney.useWhen],
     ["journey order", payload.summary.journeyOrder.join(" -> ")],
     ["surface order", payload.summary.surfaceOrder.join(" -> ")],
     ["category order", payload.summary.categoryOrder.join(" -> ")],
@@ -13320,7 +13993,7 @@ function operatorSuiteLines(payload) {
 
 // src/commands/suite.ts
 function createSuiteCommand() {
-  return new Command8("suite").description("Show the flagship and post-flagship zkSync-native operator suite").option("--wallet <name>", "Wallet name used in example commands", "main").option("--chain <chain>", "Chain key used in example commands", "zksync-sepolia").option("--include-onboarding", "Include the first-run preflight and wallet-bootstrap map", false).addHelpText(
+  return new Command9("suite").description("Show the flagship and post-flagship zkSync-native operator suite").option("--wallet <name>", "Wallet name used in example commands", "main").option("--chain <chain>", "Chain key used in example commands", "zksync-sepolia").option("--include-onboarding", "Include the first-run preflight and wallet-bootstrap map", false).addHelpText(
     "after",
     [
       "",
@@ -13340,6 +14013,9 @@ function createSuiteCommand() {
       "    unstick a write: recover paymaster/funding readiness on the workflow path",
       "    recover remote approval: move approval to the hosted relay path",
       "",
+      "  If you only need one default starting point inside suite:",
+      "    send value now",
+      "",
       "  Where `suite` hands you off next:",
       "    workflow: flagship pay, approval-based pay, and funding recovery",
       "    discovery: assets, defaults, and token inspection",
@@ -13360,11 +14036,12 @@ function createSuiteCommand() {
       "  guidance in the same packaged readout.",
       "",
       "  In JSON mode, `summary.catalogView`, `summary.entryModes`,",
-      "  `summary.journeyOrder`, `summary.surfaceOrder`, top-level `journeys[]`,",
-      "  top-level `surfaces[]`, `summary.categoryOrder`, `summary.recommendedOrder`,",
-      "  optional `preflight`, and each entry `category` + `surface` +",
-      "  `surfaceCommand` + `useWhen` field explain which slice to choose",
-      "  and which deeper surface owns it next.",
+      "  `summary.startHereJourneyId`, `summary.journeyOrder`,",
+      "  `summary.surfaceOrder`, top-level `recommendedJourney`, top-level",
+      "  `journeys[]`, top-level `surfaces[]`, `summary.categoryOrder`,",
+      "  `summary.recommendedOrder`, optional `preflight`, and each entry",
+      "  `category` + `surface` + `surfaceCommand` + `useWhen` field explain",
+      "  which slice to choose and which deeper surface owns it next.",
       "  `recommendedCommands.workflowSurface|discoverySurface|relaySurface`",
       "  expose the direct deeper-surface entry commands."
     ].join("\n")
@@ -13379,7 +14056,7 @@ function createSuiteCommand() {
 }
 
 // src/commands/tokens.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 var provider2 = new ZkSyncWalletProvider();
 function resolveTokensCommandDeps(deps) {
   return {
@@ -13509,7 +14186,7 @@ function buildTokenDiscoverySummary(result) {
 }
 function createTokensCommand(deps) {
   const resolvedDeps = resolveTokensCommandDeps(deps);
-  return new Command9("tokens").description("List discoverable tokens from the configured local-first token registry, or inspect the owned ERC-20 registry subset for one wallet").addHelpText(
+  return new Command10("tokens").description("List discoverable tokens from the configured local-first token registry, or inspect the owned ERC-20 registry subset for one wallet").addHelpText(
     "after",
     [
       "",
@@ -13714,7 +14391,7 @@ function normalizeRole2(value) {
 }
 
 // src/commands/relay.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/lib/relay.ts
 import { createServer } from "node:http";
@@ -14579,7 +15256,7 @@ function buildRelayInspectPayload(relayUrl, rawHealth) {
   };
 }
 function createRelayCommand() {
-  const relay = new Command10("relay").description(
+  const relay = new Command11("relay").description(
     "Serve and inspect the single-host connector relay baseline for hosted approval"
   );
   relay.addHelpText(
@@ -14841,7 +15518,7 @@ function createRelayCommand() {
 // src/commands/wallet.ts
 import { createServer as createServer2 } from "node:http";
 import { createInterface } from "node:readline/promises";
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 
 // ../account-profiles/src/profiles.ts
 import fs8 from "node:fs";
@@ -15426,8 +16103,9 @@ function stripSensitiveWalletRecord(wallet) {
   };
 }
 function sanitizeWalletRecord(wallet) {
+  const { walletId: _walletId, ...rest } = stripSensitiveWalletRecord(wallet);
   return {
-    ...stripSensitiveWalletRecord(wallet),
+    ...rest,
     sessionPayload: sanitizeSessionPayload(wallet.sessionPayload)
   };
 }
@@ -17508,32 +18186,32 @@ async function printBuiltinSmartAccountProfiles() {
 }
 function createWalletCommand(deps) {
   const resolvedDeps = resolveWalletCommandDeps(deps);
-  const wallet = new Command11("wallet").description(
+  const wallet = new Command12("wallet").description(
     "Create, inspect, and recover local-first wallet sessions"
   );
-  const request = new Command11("request").description("Inspect and finalize pending wallet requests");
-  const signer = new Command11("signer").description(
+  const request = new Command12("request").description("Inspect and finalize pending wallet requests");
+  const signer = new Command12("signer").description(
     "Inspect and manage the stored local execution signer for a wallet"
   );
-  const smartAccount = new Command11("smart-account").description(
+  const smartAccount = new Command12("smart-account").description(
     "Predict and deploy zkSync smart-account contracts from a supplied artifact or built-in profile"
   );
-  const sedLite = new Command11("sed-lite").description(
+  const sedLite = new Command12("sed-lite").description(
     "Inspect and manage the SED modular smart-account profile"
   );
-  const nativeCapHook = new Command11("native-cap-hook").description(
+  const nativeCapHook = new Command12("native-cap-hook").description(
     "Inspect and manage the first SED Lite validation-hook policy: native per-transaction spend caps"
   );
-  const targetAllowlistHook = new Command11("target-allowlist-hook").description(
+  const targetAllowlistHook = new Command12("target-allowlist-hook").description(
     "Inspect and manage the SED Lite validation-hook policy that restricts transactions to an allowlisted target set"
   );
-  const selectorAllowlistHook = new Command11("selector-allowlist-hook").description(
+  const selectorAllowlistHook = new Command12("selector-allowlist-hook").description(
     "Inspect and manage the SED Lite validation-hook policy that restricts contract calls to allowlisted target and selector pairs"
   );
-  const dailySpendLimit = new Command11("daily-spend-limit").description(
+  const dailySpendLimit = new Command12("daily-spend-limit").description(
     "Read and update the native-token daily spend limit used by the built-in daily-spend-limit smart-account profile"
   );
-  const paymaster = new Command11("paymaster").description(
+  const paymaster = new Command12("paymaster").description(
     "Manage saved paymaster defaults for stored wallets"
   );
   wallet.addHelpText(
@@ -18041,6 +18719,13 @@ function createWalletCommand(deps) {
   wallet.command("list").description("List stored wallets").action(async () => printWalletList());
   wallet.command("rename").description("Rename a stored wallet and update any local pending requests that reference it").option("--name <name>", "Current wallet name", "main").requiredOption("--new-name <name>", "New wallet name").action(async (options) => {
     const result = await renameWalletSession(options.name, options.newName);
+    const updatedPaymentRequestIds = await renamePaymentRequestWalletReferences(
+      {
+        walletId: result.wallet.walletId,
+        previousWalletName: options.name,
+        nextWalletName: options.newName
+      }
+    );
     printResult(
       [
         ["status", "Wallet renamed"],
@@ -18048,6 +18733,7 @@ function createWalletCommand(deps) {
         ["to", result.wallet.walletName],
         ["address", result.wallet.walletAddress],
         ["requests updated", String(result.updatedRequestIds.length)],
+        ["payment requests updated", String(updatedPaymentRequestIds.length)],
         ["workflow checkpoints updated", String(result.updatedWorkflowRequestIds.length)],
         ...walletFollowUpLines(result.wallet)
       ],
@@ -18057,6 +18743,7 @@ function createWalletCommand(deps) {
         previousWalletName: options.name,
         wallet: sanitizeWalletRecord(result.wallet),
         updatedRequestIds: result.updatedRequestIds,
+        updatedPaymentRequestIds,
         updatedWorkflowRequestIds: result.updatedWorkflowRequestIds,
         recommendedCommands: buildWalletFollowUpRecommendedCommands(result.wallet)
       }
@@ -20182,8 +20869,8 @@ function createWalletCommand(deps) {
 }
 
 // src/commands/workflow.ts
-import { randomBytes as randomBytes4 } from "node:crypto";
-import { Command as Command12 } from "commander";
+import { randomBytes as randomBytes6 } from "node:crypto";
+import { Command as Command13 } from "commander";
 var defaultProvider2 = new ZkSyncWalletProvider();
 var defaultDefiProvider2 = new ZkSyncDefiProvider({
   walletWriter: defaultProvider2
@@ -20250,7 +20937,7 @@ function parseBooleanString(value, label) {
   throw new Error(`${label} must be true or false`);
 }
 function generateWorkflowRequestId() {
-  return randomBytes4(4).toString("hex");
+  return randomBytes6(4).toString("hex");
 }
 async function reserveWorkflowRequestId(requestId) {
   const explicit = requestId?.trim();
@@ -21956,7 +22643,7 @@ function applyWorkflowHelpCommandOrder(workflow) {
 }
 function createWorkflowCommand(deps) {
   const resolvedDeps = resolveWorkflowCommandDeps(deps);
-  const workflow = new Command12("workflow").description(
+  const workflow = new Command13("workflow").description(
     "Plan, persist, and execute higher-level wallet workflows"
   );
   workflow.addHelpText("after", buildWorkflowHelpText());
@@ -22644,10 +23331,18 @@ function buildDefaultOperatorPathHelpText() {
     "  zk-agent suite",
     "  zk-agent suite --include-onboarding",
     "",
+    "First local Agent Pay primitive:",
+    "  zk-agent payment create --wallet main --to <address> --amount <amount>",
+    "  zk-agent payment list",
+    "",
     "Product routing by operator question:",
     "  next  -> bootstrap | recover | operate | workflow",
     "  suite -> operate | discover | pay | fund | recover",
     "",
+    "Payment-first default path after wallet readiness:",
+    "  send native value now -> stay on approval-based pay when fee-token/default state matters -> recover funding only when blocked",
+    "  Default start inside suite: send value now",
+    "",
     "Use `next` while the CLI still needs to choose across setup, wallet readiness, or stored workflow continuation.",
     "Use `suite` once wallet readiness is no longer the blocker and you want the packaged post-flagship surface.",
     "Use `zk-agent suite --include-onboarding` when you want one readout from first-run bootstrap through the packaged operator catalog.",
@@ -22675,6 +23370,7 @@ var ROOT_HELP_COMMAND_ORDER = [
   "wallet",
   "workflow",
   "suite",
+  "payment",
   "assets",
   "balances",
   "fund",
@@ -22708,7 +23404,7 @@ function applyRootHelpCommandOrder(program) {
   program.commands = sortedCommands;
 }
 function createProgram() {
-  const program = new Command13().name("zk-agent").description(
+  const program = new Command14().name("zk-agent").description(
     "Local-first zkSync-native CLI for wallet approval, workflow execution, and single-host hosted relay recovery"
   ).showHelpAfterError().option("--json", "Force JSON output for agent harnesses", false).hook("preAction", (thisCommand) => {
     if (thisCommand.optsWithGlobals().json) process.env.ZK_AGENT_OUTPUT = "json";
@@ -22719,6 +23415,7 @@ function createProgram() {
   program.addCommand(createAgentCommand());
   program.addCommand(createDefaultsCommand());
   program.addCommand(createSuiteCommand());
+  program.addCommand(createPaymentCommand());
   program.addCommand(createTokensCommand());
   program.addCommand(createResolveTokenCommand());
   program.addCommand(createRelayCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zk-agent-cli",
-  "version": "0.1.0-rc.3",
+  "version": "0.1.0-rc.4",
   "description": "Local-first zkSync Era and ZK Stack agent CLI with wallet session recovery, workflow orchestration, relay-backed approval, and SED smart-account support.",
   "license": "MIT",
   "type": "module",
@@ -67,6 +67,7 @@
   "devDependencies": {
     "@zk-agent/account-profiles": "workspace:*",
     "@zk-agent/agent-core": "workspace:*",
+    "@zk-agent/agent-pay": "workspace:*",
     "@zk-agent/agent-session-protocol": "workspace:*",
     "@zk-agent/plugin-identity": "workspace:*",
     "@zk-agent/provider-zksync-defi": "workspace:*",