zk-agent-cli 0.1.0-rc.8 → 1.0.0

package/dist/index.js

@@ -8069,6 +8069,15 @@ function buildPaymentSubmitRecommendedCommand(walletName = "main") {
 function buildWorkspaceRecommendedCommand() {
   return "zk-agent workspace";
 }
+function buildApprovalRecommendedCommand(requestId) {
+  return `zk-agent approval --request-id ${requestId}`;
+}
+function buildHandoffRecommendedCommand(requestId) {
+  return `zk-agent handoff --request-id ${requestId}`;
+}
+function buildFeedRecommendedCommand() {
+  return "zk-agent feed";
+}
 function buildPaymentWorkspaceRecommendedCommand() {
   return "zk-agent payment workspace";
 }
@@ -10379,12 +10388,18 @@ function buildSetupHelpText() {
     "  Connector URL:   http://localhost:4444",
     "  Override --default-chain or --connector-url only when you intentionally deviate from that path.",
     "",
+    "After setup, choose the entrypoint that fits:",
+    "  zk-agent start  -> public first touch",
+    "  zk-agent next   -> canonical live routing contract",
+    "",
     "Then stay on the default local-first path:",
     "  zk-agent next",
     "  zk-agent wallet create --await-local",
     "  zk-agent next",
     `  ${buildTopLevelPayRecommendedCommand("main")}`,
-    "  Stop after the first successful workflow pay.",
+    "  Stop after the first successful pay.",
+    "  Approved wallets auto-sync local smart-account metadata when chain reads are available,",
+    "  so the default path does not depend on a separate manual wallet sync.",
     "",
     "Use the remote-browser variant only when the browser cannot return to this terminal:",
     "  zk-agent relay baseline --relay-url <url>",
@@ -10974,10 +10989,10 @@ function buildSuiteHandoffPublicJourneyProofPath(journeyId, walletName) {
       return [
         buildSubmitRecommendedCommand(walletName),
         buildPaymentNextRecommendedCommand("<request-id>"),
-        buildPaymentApprovalRecommendedCommand("<request-id>"),
+        buildApprovalRecommendedCommand("<request-id>"),
         buildWorkspaceRecommendedCommand(),
-        buildPaymentHandoffRecommendedCommand("<request-id>"),
-        buildPaymentFeedRecommendedCommand()
+        buildHandoffRecommendedCommand("<request-id>"),
+        buildFeedRecommendedCommand()
       ];
     case "inspect-before-acting":
     case "unstick-a-write":
@@ -11365,6 +11380,7 @@ function buildNextHelpText() {
   return [
     "",
     "Use `start` for public first touch. Keep `next` as the live routing contract.",
+    "If local defaults do not exist yet, the first answer is still `zk-agent setup`.",
     "",
     "Default first-run path:",
     "  zk-agent setup",
@@ -11372,7 +11388,9 @@ function buildNextHelpText() {
     "  zk-agent wallet create --await-local",
     "  zk-agent next",
     `  ${buildTopLevelPayRecommendedCommand("main")}`,
-    "  Stop after the first successful workflow pay.",
+    "  Stop after the first successful pay.",
+    "  Approved wallets auto-sync local smart-account metadata when chain reads are available,",
+    "  so the default path does not depend on a separate manual wallet sync.",
     "",
     "Before that first success:",
     "  Ignore suite, payment, and relay unless the CLI points you there or the browser is remote.",
@@ -11432,6 +11450,7 @@ function buildStartHelpText() {
     "`start` is the shortest public first-touch command.",
     "Use it when you want one obvious entrypoint but still want the same",
     "output contract and runtime behavior as `zk-agent next`.",
+    "On a clean machine, the first answer will usually still be `zk-agent setup`.",
     "",
     "Shortest first proof:",
     "  zk-agent setup",
@@ -11439,7 +11458,9 @@ function buildStartHelpText() {
     "  zk-agent wallet create --await-local",
     "  zk-agent next",
     `  ${buildTopLevelPayRecommendedCommand("main")}`,
-    "  Stop after the first successful workflow pay.",
+    "  Stop after the first successful pay.",
+    "  Approved wallets auto-sync local smart-account metadata when chain reads are available,",
+    "  so the default path does not depend on a separate manual wallet sync.",
     "",
     "What not to learn first:",
     "  Ignore suite, payment, and relay until that baseline path works once,",
@@ -15253,26 +15274,37 @@ function buildPaymentExecuteCommand(plan) {
     paymasterMode: plan.paymasterMode
   });
 }
-function buildPaymentRecommendedCommands(record, executionPlan) {
+function buildPaymentRecommendedCommands(record, executionPlan, options = {}) {
+  const walletName = executionPlan.walletName;
+  const topLevel = options.topLevel ?? false;
   const markPaidCommand = buildPaymentSetStatusRecommendedCommand(
     record.requestId,
     "paid",
     record.settlement.txHash || "<tx-hash>"
   );
   return {
-    submit: buildPaymentSubmitRecommendedCommand(),
-    workspace: buildPaymentWorkspaceRecommendedCommand(),
+    submit: topLevel ? buildSubmitRecommendedCommand(walletName) : buildPaymentSubmitRecommendedCommand(walletName),
+    workspace: topLevel ? buildWorkspaceRecommendedCommand() : buildPaymentWorkspaceRecommendedCommand(),
     dashboard: buildPaymentDashboardRecommendedCommand(),
-    feed: buildPaymentFeedRecommendedCommand(),
+    feed: topLevel ? buildFeedRecommendedCommand() : buildPaymentFeedRecommendedCommand(),
     queue: buildPaymentQueueRecommendedCommand(),
     report: buildPaymentReportRecommendedCommand(),
-    approval: buildPaymentApprovalRecommendedCommand(record.requestId),
+    approval: topLevel ? buildApprovalRecommendedCommand(record.requestId) : buildPaymentApprovalRecommendedCommand(record.requestId),
+    ...topLevel ? {
+      paymentSubmit: buildPaymentSubmitRecommendedCommand(walletName),
+      paymentWorkspace: buildPaymentWorkspaceRecommendedCommand(),
+      paymentFeed: buildPaymentFeedRecommendedCommand(),
+      paymentApproval: buildPaymentApprovalRecommendedCommand(record.requestId)
+    } : {},
     syncApproval: buildPaymentSyncApprovalRecommendedCommand(record.requestId),
     list: buildPaymentListRecommendedCommand(),
     show: buildPaymentShowRecommendedCommand(record.requestId),
     inspect: buildPaymentInspectRecommendedCommand(record.requestId),
     next: buildPaymentNextRecommendedCommand(record.requestId),
-    handoff: buildPaymentHandoffRecommendedCommand(record.requestId),
+    handoff: topLevel ? buildHandoffRecommendedCommand(record.requestId) : buildPaymentHandoffRecommendedCommand(record.requestId),
+    ...topLevel ? {
+      paymentHandoff: buildPaymentHandoffRecommendedCommand(record.requestId)
+    } : {},
     intent: buildPaymentIntentRecommendedCommand(record.requestId),
     parties: buildPaymentPartiesRecommendedCommand(record.requestId),
     describe: buildPaymentDescribeRecommendedCommand(record.requestId),
@@ -15531,9 +15563,25 @@ function paymentIntentLines(intent, inspectCommand, handoffCommand, partiesComma
   lines.push(["metadata keys", String(Object.keys(intent.metadata).length)]);
   return lines;
 }
+function buildAgentPayProductLayer(surface) {
+  return {
+    stage: "local-first-workbench",
+    publicShell: "submit -> next -> approval -> workspace -> handoff -> feed",
+    productClaim: "compact ingress, wallet-aware follow-up, one cross-request workspace, and stable exports",
+    surfaceRole: surface === "workspace" ? "cross-request-workbench" : surface === "handoff" ? "single-request-export" : "cross-request-export",
+    platformDirection: "handoff and feed are already shaped for external dashboards, agents, or backend ingestion",
+    boundary: "local-first only today; not a hosted multi-tenant control plane"
+  };
+}
 function paymentHandoffLines(handoff, inspectCommand, partiesCommand, shareCommand, settlementCommand) {
+  const productLayer = buildAgentPayProductLayer("handoff");
   const lines = [
     ["request", handoff.requestId],
+    ["product stage", productLayer.stage],
+    ["product claim", productLayer.productClaim],
+    ["surface role", productLayer.surfaceRole],
+    ["platform direction", productLayer.platformDirection],
+    ["boundary", productLayer.boundary],
     ["source", handoff.source],
     ["chain", `${handoff.chain} (${handoff.chainId})`],
     ["status", handoff.summary.settlementStatus],
@@ -15789,21 +15837,27 @@ function paymentIngressLines(input) {
     ["history", input.historyCommand]
   ];
 }
-function paymentWorkspaceLines(workspace, workspaceCommand = buildDefaultPaymentWorkspaceCommand(), submitCommand = buildDefaultPaymentSubmitCommand()) {
+function paymentWorkspaceLines(workspace, workspaceCommand = buildDefaultPaymentWorkspaceCommand(), submitCommand = buildDefaultPaymentSubmitCommand(), approvalCommand = buildPaymentApprovalRecommendedCommand("<request-id>"), handoffCommand = buildPaymentHandoffRecommendedCommand("<request-id>"), feedCommand = buildPaymentFeedRecommendedCommand()) {
   const walletName = workspace.filters.walletName || "main";
+  const productLayer = buildAgentPayProductLayer("workspace");
   const lines = [
     ["surface", "cross-request Agent Pay workspace"],
     [
       "use when",
       "request capture is no longer enough and you need one current operator view across requests"
     ],
-    ["public shell", "submit -> next -> approval -> workspace -> handoff -> feed"],
+    ["product stage", productLayer.stage],
+    ["product claim", productLayer.productClaim],
+    ["surface role", productLayer.surfaceRole],
+    ["public shell", productLayer.publicShell],
+    ["platform direction", productLayer.platformDirection],
+    ["boundary", productLayer.boundary],
     ["generated", workspace.generatedAt],
     ["source", workspace.source],
     ["submit", submitCommand || buildPaymentSubmitRecommendedCommand(walletName)],
     ["payment next", buildPaymentNextRecommendedCommand("<request-id>")],
-    ["approval", buildPaymentApprovalRecommendedCommand("<request-id>")],
-    ["handoff", buildPaymentHandoffRecommendedCommand("<request-id>")],
+    ["approval", approvalCommand],
+    ["handoff", handoffCommand],
     ["requests", String(workspace.summary.totalRequests)],
     ["wallet groups", String(workspace.summary.distinctWalletCount)],
     ["actionable", String(workspace.summary.actionableRequests)],
@@ -15818,7 +15872,7 @@ function paymentWorkspaceLines(workspace, workspaceCommand = buildDefaultPayment
     ["recent activity", String(workspace.summary.recentActivityCount)],
     ["workspace", workspaceCommand],
     ["dashboard", buildPaymentDashboardRecommendedCommand()],
-    ["feed", buildPaymentFeedRecommendedCommand()],
+    ["feed", feedCommand],
     ["queue", buildPaymentQueueRecommendedCommand()],
     ["report", buildPaymentReportRecommendedCommand()]
   ];
@@ -15870,15 +15924,15 @@ function buildWorkspaceSurfaceHelpText(options) {
       "    Use this when you already know the current question is the cross-request Agent Pay workbench.",
       "    This is the top-level shortcut for `zk-agent payment workspace`.",
       "    Stay on `suite` when the question is broader than the Agent Pay workbench.",
-      "    Stay on `payment next`, `payment approval`, or `payment handoff` when the question is still one request lifecycle.",
+      "    Stay on `payment next`, `approval`, or `handoff` when the question is still one request lifecycle.",
       "",
       "  Common commands:",
       `    ${options.workspaceCommand}`,
       `    ${options.submitCommand}`,
       "    zk-agent payment next --request-id <id>",
-      "    zk-agent payment approval --request-id <id>",
-      "    zk-agent payment handoff --request-id <id>",
-      "    zk-agent payment feed"
+      `    ${options.approvalCommand}`,
+      `    ${options.handoffCommand}`,
+      `    ${options.feedCommand}`
     ].join("\n");
   }
   return [
@@ -15896,7 +15950,7 @@ function buildWorkspaceSurfaceHelpText(options) {
     "    zk-agent payment next --request-id <id>",
     "    zk-agent payment approval --request-id <id>",
     "    zk-agent payment handoff --request-id <id>",
-    "    zk-agent payment feed"
+    `    ${options.feedCommand}`
   ].join("\n");
 }
 function addWorkspaceSurfaceCommand(command, options) {
@@ -15908,6 +15962,9 @@ function addWorkspaceSurfaceCommand(command, options) {
     buildWorkspaceSurfaceHelpText({
       workspaceCommand: options.workspaceCommand,
       submitCommand: options.submitCommand,
+      approvalCommand: options.approvalCommand,
+      handoffCommand: options.handoffCommand,
+      feedCommand: options.feedCommand,
       topLevel: options.topLevel
     })
   ).action(async (workspaceOptions) => {
@@ -15929,10 +15986,19 @@ function addWorkspaceSurfaceCommand(command, options) {
     });
     const walletName = result.workspace.filters.walletName || "main";
     const submitCommand = options.topLevel ? buildSubmitRecommendedCommand(walletName) : buildPaymentSubmitRecommendedCommand(walletName);
+    const feedCommand = options.topLevel ? buildFeedRecommendedCommand() : buildPaymentFeedRecommendedCommand();
     printResult(
-      paymentWorkspaceLines(result.workspace, options.workspaceCommand, submitCommand),
+      paymentWorkspaceLines(
+        result.workspace,
+        options.workspaceCommand,
+        submitCommand,
+        options.topLevel ? buildApprovalRecommendedCommand("<request-id>") : buildPaymentApprovalRecommendedCommand("<request-id>"),
+        options.topLevel ? buildHandoffRecommendedCommand("<request-id>") : buildPaymentHandoffRecommendedCommand("<request-id>"),
+        feedCommand
+      ),
       {
         ok: true,
+        productLayer: buildAgentPayProductLayer("workspace"),
         workspace: {
           ...result.workspace,
           queue: {
@@ -15947,17 +16013,24 @@ function addWorkspaceSurfaceCommand(command, options) {
         recommendedCommands: {
           workspace: options.workspaceCommand,
           ...options.topLevel ? {
+            approval: buildApprovalRecommendedCommand("<request-id>"),
+            paymentApproval: buildPaymentApprovalRecommendedCommand("<request-id>"),
+            handoff: buildHandoffRecommendedCommand("<request-id>"),
+            paymentHandoff: buildPaymentHandoffRecommendedCommand("<request-id>"),
+            feed: buildFeedRecommendedCommand(),
+            paymentFeed: buildPaymentFeedRecommendedCommand(),
             paymentSubmit: buildPaymentSubmitRecommendedCommand(walletName),
             paymentWorkspace: buildPaymentWorkspaceRecommendedCommand()
-          } : {},
+          } : {
+            approval: buildPaymentApprovalRecommendedCommand("<request-id>"),
+            handoff: buildPaymentHandoffRecommendedCommand("<request-id>"),
+            feed: buildPaymentFeedRecommendedCommand()
+          },
           dashboard: buildPaymentDashboardRecommendedCommand(),
-          feed: buildPaymentFeedRecommendedCommand(),
           queue: buildPaymentQueueRecommendedCommand(),
           report: buildPaymentReportRecommendedCommand(),
           submit: submitCommand,
-          next: buildPaymentNextRecommendedCommand("<request-id>"),
-          approval: buildPaymentApprovalRecommendedCommand("<request-id>"),
-          handoff: buildPaymentHandoffRecommendedCommand("<request-id>")
+          next: buildPaymentNextRecommendedCommand("<request-id>")
         }
       }
     );
@@ -15971,6 +16044,9 @@ function createWorkspaceCommand() {
     {
       workspaceCommand: buildWorkspaceRecommendedCommand(),
       submitCommand: buildSubmitRecommendedCommand(),
+      approvalCommand: buildApprovalRecommendedCommand("<request-id>"),
+      handoffCommand: buildHandoffRecommendedCommand("<request-id>"),
+      feedCommand: buildFeedRecommendedCommand(),
       topLevel: true
     }
   );
@@ -15988,10 +16064,10 @@ function buildSubmitSurfaceHelpText(options) {
       "  Common commands:",
       `    ${options.submitCommand}`,
       "    zk-agent payment next --request-id <id>",
-      "    zk-agent payment approval --request-id <id>",
+      "    zk-agent approval --request-id <id>",
       "    zk-agent workspace",
-      "    zk-agent payment handoff --request-id <id>",
-      "    zk-agent payment feed"
+      `    ${options.handoffCommand}`,
+      `    ${options.feedCommand}`
     ].join("\n");
   }
   return [
@@ -16008,7 +16084,7 @@ function buildSubmitSurfaceHelpText(options) {
     "    zk-agent payment approval --request-id <id>",
     "    zk-agent workspace",
     "    zk-agent payment handoff --request-id <id>",
-    "    zk-agent payment feed"
+    `    ${options.feedCommand}`
   ].join("\n");
 }
 async function executePaymentSubmitSurface(options, topLevel) {
@@ -16042,13 +16118,9 @@ async function executePaymentSubmitSurface(options, topLevel) {
       next: result.next,
       nextCommand,
       recommendedCommands: {
-        ...buildPaymentRecommendedCommands(result.paymentRequest, result.executionPlan),
-        submit: topLevel ? buildSubmitRecommendedCommand(walletName) : buildPaymentSubmitRecommendedCommand(walletName),
-        ...topLevel ? {
-          workspace: buildWorkspaceRecommendedCommand(),
-          paymentWorkspace: buildPaymentWorkspaceRecommendedCommand(),
-          paymentSubmit: buildPaymentSubmitRecommendedCommand(walletName)
-        } : {}
+        ...buildPaymentRecommendedCommands(result.paymentRequest, result.executionPlan, {
+          topLevel
+        })
       }
     }
   );
@@ -16061,6 +16133,8 @@ function addSubmitSurfaceCommand(command, options) {
     "after",
     buildSubmitSurfaceHelpText({
       submitCommand: options.submitCommand,
+      handoffCommand: options.handoffCommand,
+      feedCommand: options.feedCommand,
       topLevel: options.topLevel
     })
   ).action(async (submitOptions) => {
@@ -16077,6 +16151,8 @@ function createSubmitCommand() {
     ),
     {
       submitCommand: buildSubmitRecommendedCommand(),
+      handoffCommand: buildHandoffRecommendedCommand("<request-id>"),
+      feedCommand: buildFeedRecommendedCommand(),
       topLevel: true
     }
   );
@@ -16134,8 +16210,16 @@ function paymentDashboardLines(dashboard) {
   }
   return lines;
 }
-function paymentFeedLines(feed) {
+function paymentFeedLines(feed, options = {}) {
+  const productLayer = buildAgentPayProductLayer("feed");
+  const workspaceCommand = options.workspaceCommand ?? buildPaymentWorkspaceRecommendedCommand();
+  const feedCommand = options.feedCommand ?? buildPaymentFeedRecommendedCommand();
   const lines = [
+    ["product stage", productLayer.stage],
+    ["product claim", productLayer.productClaim],
+    ["surface role", productLayer.surfaceRole],
+    ["platform direction", productLayer.platformDirection],
+    ["boundary", productLayer.boundary],
     ["generated", feed.generatedAt],
     ["source", feed.source],
     ["requests", String(feed.summary.totalRequests)],
@@ -16148,8 +16232,8 @@ function paymentFeedLines(feed) {
     ["awaiting confirmation", String(feed.summary.awaitingConfirmationRequests)],
     ["retryable", String(feed.summary.retryableRequests)],
     ["items shown", String(feed.items.length)],
-    ["workspace", buildPaymentWorkspaceRecommendedCommand()],
-    ["feed", buildPaymentFeedRecommendedCommand()],
+    ["workspace", workspaceCommand],
+    ["feed", feedCommand],
     ["dashboard", buildPaymentDashboardRecommendedCommand()],
     ["queue", buildPaymentQueueRecommendedCommand()],
     ["report", buildPaymentReportRecommendedCommand()]
@@ -16172,6 +16256,273 @@ function paymentFeedLines(feed) {
   }
   return lines;
 }
+function buildFeedSurfaceHelpText(options) {
+  if (options.topLevel) {
+    return [
+      "",
+      "  Public feed shortcut:",
+      "    Use this when the current question is already the integration-ready cross-request Agent Pay export.",
+      "    This is the top-level shortcut for `zk-agent payment feed`.",
+      "    Stay on `workspace` when you still need the broader cross-request Agent Pay workbench.",
+      "    Stay on `handoff` when the current question is still one single-request export.",
+      "",
+      "  Common commands:",
+      `    ${options.feedCommand}`,
+      `    ${options.workspaceCommand}`,
+      `    ${options.handoffCommand}`,
+      "    zk-agent payment dashboard",
+      "    zk-agent payment queue",
+      "    zk-agent payment report",
+      `    ${options.submitCommand}`
+    ].join("\n");
+  }
+  return [
+    "",
+    "  Integration-ready feed surface:",
+    "    Use this when you need the stable cross-request Agent Pay batch export for dashboards, agents, or backend ingestion.",
+    "    Public shortcut: zk-agent feed.",
+    "    Stay on `payment workspace` when you still need the broader cross-request workbench first.",
+    "    Stay on `payment handoff` when the current question is still one single-request export.",
+    "",
+    "  Common commands:",
+    `    ${options.feedCommand}`,
+    `    ${options.workspaceCommand}`,
+    "    zk-agent payment handoff --request-id <id>",
+    "    zk-agent payment dashboard",
+    "    zk-agent payment queue",
+    "    zk-agent payment report",
+    `    ${options.submitCommand}`
+  ].join("\n");
+}
+function addFeedSurfaceCommand(command, options) {
+  return command.option("--wallet <name>", "Optional payer wallet filter").option(
+    "--status <status>",
+    "Optional status filter: draft, approval_pending, ready, paid, failed, expired, or cancelled"
+  ).option("--limit <count>", "Optional maximum number of feed items to return").addHelpText(
+    "after",
+    buildFeedSurfaceHelpText({
+      feedCommand: options.feedCommand,
+      workspaceCommand: options.workspaceCommand,
+      handoffCommand: options.handoffCommand,
+      submitCommand: options.submitCommand,
+      topLevel: options.topLevel
+    })
+  ).action(async (feedOptions) => {
+    const statusFilter = feedOptions.status ? resolvePaymentStatus(feedOptions.status) : void 0;
+    const limit = resolvePositiveInteger(feedOptions.limit, "--limit");
+    const result = await buildStoredPaymentRequestsFeed({
+      walletName: feedOptions.wallet,
+      status: statusFilter,
+      limit
+    });
+    const walletName = result.feed.filters.walletName || "main";
+    const workspaceCommand = options.topLevel ? buildWorkspaceRecommendedCommand() : buildPaymentWorkspaceRecommendedCommand();
+    const feedCommand = options.topLevel ? buildFeedRecommendedCommand() : buildPaymentFeedRecommendedCommand();
+    const submitCommand = options.topLevel ? buildSubmitRecommendedCommand(walletName) : buildPaymentSubmitRecommendedCommand(walletName);
+    printResult(
+      paymentFeedLines(result.feed, { workspaceCommand, feedCommand }),
+      {
+        ok: true,
+        productLayer: buildAgentPayProductLayer("feed"),
+        feed: result.feed,
+        recommendedCommands: {
+          workspace: workspaceCommand,
+          ...options.topLevel ? {
+            handoff: buildHandoffRecommendedCommand("<request-id>"),
+            paymentHandoff: buildPaymentHandoffRecommendedCommand("<request-id>"),
+            feed: buildFeedRecommendedCommand(),
+            paymentFeed: buildPaymentFeedRecommendedCommand(),
+            paymentWorkspace: buildPaymentWorkspaceRecommendedCommand(),
+            paymentSubmit: buildPaymentSubmitRecommendedCommand(walletName)
+          } : {
+            feed: buildPaymentFeedRecommendedCommand()
+          },
+          dashboard: buildPaymentDashboardRecommendedCommand(),
+          queue: buildPaymentQueueRecommendedCommand(),
+          report: buildPaymentReportRecommendedCommand(),
+          submit: submitCommand
+        }
+      }
+    );
+  });
+}
+function createFeedCommand() {
+  return addFeedSurfaceCommand(
+    new Command7("feed").description(
+      "Public shortcut for the integration-ready cross-request Agent Pay feed export"
+    ),
+    {
+      feedCommand: buildFeedRecommendedCommand(),
+      workspaceCommand: buildWorkspaceRecommendedCommand(),
+      handoffCommand: buildHandoffRecommendedCommand("<request-id>"),
+      submitCommand: buildSubmitRecommendedCommand(),
+      topLevel: true
+    }
+  );
+}
+function buildHandoffSurfaceHelpText(options) {
+  if (options.topLevel) {
+    return [
+      "",
+      "  Public handoff shortcut:",
+      "    Use this when the current question is already the stable single-request Agent Pay export.",
+      "    This is the top-level shortcut for `zk-agent payment handoff`.",
+      "    Stay on `workspace` when you still need the broader cross-request Agent Pay workbench.",
+      "    Stay on `feed` when the current question has already widened to the cross-request batch export.",
+      "",
+      "  Common commands:",
+      `    ${options.handoffCommand}`,
+      `    ${options.workspaceCommand}`,
+      `    ${options.feedCommand}`,
+      "    zk-agent payment inspect --request-id <id>",
+      "    zk-agent payment parties --request-id <id>",
+      "    zk-agent payment share --request-id <id>",
+      "    zk-agent payment settlement --request-id <id>"
+    ].join("\n");
+  }
+  return [
+    "",
+    "  Integration-ready handoff surface:",
+    "    Use this when you need one stable local-first Agent Pay export bundle for an external dashboard, agent, or backend.",
+    "    Public shortcut: zk-agent handoff.",
+    "    Stay on `payment inspect` when you still need the broader single-request aggregate view.",
+    "    Stay on `payment share` or `payment parties` when the question has already narrowed to one projection.",
+    "",
+    "  Common commands:",
+    `    ${options.handoffCommand}`,
+    "    zk-agent payment inspect --request-id <id>",
+    "    zk-agent payment parties --request-id <id>",
+    "    zk-agent payment share --request-id <id>",
+    "    zk-agent payment settlement --request-id <id>",
+    `    ${options.workspaceCommand}`,
+    `    ${options.feedCommand}`
+  ].join("\n");
+}
+async function executePaymentHandoffSurface(requestId, topLevel) {
+  const result = await getStoredPaymentRequestHandoff(requestId);
+  printResult(
+    paymentHandoffLines(
+      result.handoff,
+      buildPaymentInspectRecommendedCommand(result.paymentRequest.requestId),
+      buildPaymentPartiesRecommendedCommand(result.paymentRequest.requestId),
+      buildPaymentShareRecommendedCommand(result.paymentRequest.requestId),
+      buildPaymentSettlementRecommendedCommand(result.paymentRequest.requestId)
+    ),
+    {
+      ok: true,
+      requestId: result.paymentRequest.requestId,
+      productLayer: buildAgentPayProductLayer("handoff"),
+      handoff: result.handoff,
+      recommendedCommands: buildPaymentRecommendedCommands(
+        result.paymentRequest,
+        result.executionPlan,
+        { topLevel }
+      )
+    }
+  );
+}
+function addHandoffSurfaceCommand(command, options) {
+  return command.requiredOption("--request-id <id>", "Stored payment request id").addHelpText(
+    "after",
+    buildHandoffSurfaceHelpText({
+      handoffCommand: options.handoffCommand,
+      workspaceCommand: options.workspaceCommand,
+      feedCommand: options.feedCommand,
+      topLevel: options.topLevel
+    })
+  ).action(async (optionsWithRequest) => {
+    await executePaymentHandoffSurface(optionsWithRequest.requestId, options.topLevel);
+  });
+}
+function createHandoffCommand() {
+  return addHandoffSurfaceCommand(
+    new Command7("handoff").description(
+      "Public shortcut for the stable single-request Agent Pay export bundle"
+    ),
+    {
+      handoffCommand: buildHandoffRecommendedCommand("<request-id>"),
+      workspaceCommand: buildWorkspaceRecommendedCommand(),
+      feedCommand: buildFeedRecommendedCommand(),
+      topLevel: true
+    }
+  );
+}
+function buildApprovalSurfaceHelpText(options) {
+  if (options.topLevel) {
+    return [
+      "",
+      "  Public approval shortcut:",
+      "    Use this when the current question is approval readiness for one stored Agent Pay request.",
+      "    This is the top-level shortcut for `zk-agent payment approval`.",
+      "    Stay on `workspace` when the question has widened to the cross-request workbench.",
+      "    Stay on `handoff` when you already need the stable single-request export bundle.",
+      "",
+      "  Common commands:",
+      `    ${options.approvalCommand}`,
+      "    zk-agent payment next --request-id <id>",
+      "    zk-agent workspace",
+      "    zk-agent handoff --request-id <id>",
+      "    zk-agent payment sync-approval --request-id <id>"
+    ].join("\n");
+  }
+  return [
+    "",
+    "  Approval readiness surface:",
+    "    Use this when you need the request-linked wallet approval state before moving back to execution or export.",
+    "    Public shortcut: zk-agent approval.",
+    "    Stay on `payment sync-approval` when you want to reconcile the local request status with the current wallet approval state.",
+    "",
+    "  Common commands:",
+    `    ${options.approvalCommand}`,
+    "    zk-agent payment next --request-id <id>",
+    "    zk-agent payment sync-approval --request-id <id>",
+    "    zk-agent payment inspect --request-id <id>",
+    "    zk-agent payment history --request-id <id>"
+  ].join("\n");
+}
+async function executePaymentApprovalSurface(requestId, topLevel) {
+  const result = await getStoredPaymentRequestApproval(requestId);
+  const nextCommand = buildPaymentApprovalCommand(result.approval);
+  printResult(
+    paymentApprovalLines({
+      approval: result.approval,
+      nextCommand
+    }),
+    {
+      ok: true,
+      requestId: result.paymentRequest.requestId,
+      approval: result.approval,
+      nextCommand,
+      recommendedCommands: buildPaymentRecommendedCommands(
+        result.paymentRequest,
+        result.executionPlan,
+        { topLevel }
+      )
+    }
+  );
+}
+function addApprovalSurfaceCommand(command, options) {
+  return command.requiredOption("--request-id <id>", "Stored payment request id").addHelpText(
+    "after",
+    buildApprovalSurfaceHelpText({
+      approvalCommand: options.approvalCommand,
+      topLevel: options.topLevel
+    })
+  ).action(async (approvalOptions) => {
+    await executePaymentApprovalSurface(approvalOptions.requestId, options.topLevel);
+  });
+}
+function createApprovalCommand() {
+  return addApprovalSurfaceCommand(
+    new Command7("approval").description(
+      "Public shortcut for approval readiness on one stored Agent Pay request"
+    ),
+    {
+      approvalCommand: buildApprovalRecommendedCommand("<request-id>"),
+      topLevel: true
+    }
+  );
+}
 function paymentReportLines(report) {
   const lines = [
     ["generated", report.generatedAt],
@@ -16390,19 +16741,19 @@ function createPaymentCommand() {
       "  Fastest proof path:",
       "    zk-agent submit --wallet main --to <address> --amount <amount>",
       "    zk-agent payment next --request-id <id>",
-      "    zk-agent payment approval --request-id <id>",
+      "    zk-agent approval --request-id <id>",
       "    zk-agent workspace",
-      "    zk-agent payment handoff --request-id <id>",
-      "    zk-agent payment feed",
+      "    zk-agent handoff --request-id <id>",
+      "    zk-agent feed",
       "    This proves compact ingress -> wallet-aware follow-up -> approval readiness -> cross-request workspace -> integration-ready export.",
       "",
       "  Public start here:",
       "    zk-agent submit --wallet main --to <address> --amount <amount>",
       "    zk-agent workspace",
-      "    zk-agent payment feed",
-      "    zk-agent payment approval --request-id <id>",
+      "    zk-agent handoff --request-id <id>",
+      "    zk-agent feed",
+      "    zk-agent approval --request-id <id>",
       "    zk-agent payment next --request-id <id>",
-      "    zk-agent payment handoff --request-id <id>",
       "",
       "  Operator views when the request layer gets broader:",
       "    zk-agent payment dashboard",
@@ -16446,10 +16797,10 @@ function createPaymentCommand() {
       "  Stored request management:",
       "    zk-agent workspace",
       "    zk-agent payment dashboard",
-      "    zk-agent payment feed",
+      "    zk-agent feed",
       "    zk-agent payment queue",
       "    zk-agent payment report",
-      "    zk-agent payment approval --request-id <id>",
+      "    zk-agent approval --request-id <id>",
       "    zk-agent payment sync-approval --request-id <id>",
       "    zk-agent payment list",
       "    zk-agent payment history --request-id <id>",
@@ -16462,6 +16813,8 @@ function createPaymentCommand() {
     ),
     {
       submitCommand: buildPaymentSubmitRecommendedCommand(),
+      handoffCommand: buildPaymentHandoffRecommendedCommand("<request-id>"),
+      feedCommand: buildPaymentFeedRecommendedCommand(),
       topLevel: false
     }
   );
@@ -16532,6 +16885,9 @@ function createPaymentCommand() {
       {
         workspaceCommand: buildPaymentWorkspaceRecommendedCommand(),
         submitCommand: buildPaymentSubmitRecommendedCommand(),
+        approvalCommand: buildPaymentApprovalRecommendedCommand("<request-id>"),
+        handoffCommand: buildPaymentHandoffRecommendedCommand("<request-id>"),
+        feedCommand: buildPaymentFeedRecommendedCommand(),
         topLevel: false
       }
     )
@@ -16569,32 +16925,20 @@ function createPaymentCommand() {
       }
     });
   });
-  payment.command("feed").description(
-    "Build the integration-ready feed slice inside the cross-request Agent Pay workspace"
-  ).option("--wallet <name>", "Optional payer wallet filter").option(
-    "--status <status>",
-    "Optional status filter: draft, approval_pending, ready, paid, failed, expired, or cancelled"
-  ).option("--limit <count>", "Optional maximum number of feed items to return").action(async (options) => {
-    const statusFilter = options.status ? resolvePaymentStatus(options.status) : void 0;
-    const limit = resolvePositiveInteger(options.limit, "--limit");
-    const result = await buildStoredPaymentRequestsFeed({
-      walletName: options.wallet,
-      status: statusFilter,
-      limit
-    });
-    printResult(paymentFeedLines(result.feed), {
-      ok: true,
-      feed: result.feed,
-      recommendedCommands: {
-        workspace: buildPaymentWorkspaceRecommendedCommand(),
-        dashboard: buildPaymentDashboardRecommendedCommand(),
-        feed: buildPaymentFeedRecommendedCommand(),
-        queue: buildPaymentQueueRecommendedCommand(),
-        report: buildPaymentReportRecommendedCommand(),
-        submit: buildPaymentSubmitRecommendedCommand()
+  payment.addCommand(
+    addFeedSurfaceCommand(
+      new Command7("feed").description(
+        "Build the integration-ready feed slice inside the cross-request Agent Pay workspace"
+      ),
+      {
+        feedCommand: buildPaymentFeedRecommendedCommand(),
+        workspaceCommand: buildPaymentWorkspaceRecommendedCommand(),
+        handoffCommand: buildPaymentHandoffRecommendedCommand("<request-id>"),
+        submitCommand: buildPaymentSubmitRecommendedCommand(),
+        topLevel: false
       }
-    });
-  });
+    )
+  );
   payment.command("queue").description(
     "Build the wallet-aware queue slice inside the cross-request Agent Pay workspace"
   ).option("--wallet <name>", "Optional payer wallet filter").option(
@@ -16654,26 +16998,17 @@ function createPaymentCommand() {
       }
     });
   });
-  payment.command("approval").description("Inspect linked wallet approval readiness for one stored payment request").requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
-    const result = await getStoredPaymentRequestApproval(options.requestId);
-    const nextCommand = buildPaymentApprovalCommand(result.approval);
-    printResult(
-      paymentApprovalLines({
-        approval: result.approval,
-        nextCommand
-      }),
+  payment.addCommand(
+    addApprovalSurfaceCommand(
+      new Command7("approval").description(
+        "Inspect linked wallet approval readiness for one stored payment request"
+      ),
       {
-        ok: true,
-        requestId: result.paymentRequest.requestId,
-        approval: result.approval,
-        nextCommand,
-        recommendedCommands: buildPaymentRecommendedCommands(
-          result.paymentRequest,
-          result.executionPlan
-        )
+        approvalCommand: buildPaymentApprovalRecommendedCommand("<request-id>"),
+        topLevel: false
       }
-    );
-  });
+    )
+  );
   payment.command("sync-approval").description(
     "Synchronize one stored payment request with the linked wallet approval state"
   ).requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
@@ -16845,29 +17180,19 @@ function createPaymentCommand() {
       }
     );
   });
-  payment.command("handoff").description(
-    "Render one stored payment request as an integration-ready bundle for external dashboards, agents, or backend ingestion"
-  ).requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
-    const result = await getStoredPaymentRequestHandoff(options.requestId);
-    printResult(
-      paymentHandoffLines(
-        result.handoff,
-        buildPaymentInspectRecommendedCommand(result.paymentRequest.requestId),
-        buildPaymentPartiesRecommendedCommand(result.paymentRequest.requestId),
-        buildPaymentShareRecommendedCommand(result.paymentRequest.requestId),
-        buildPaymentSettlementRecommendedCommand(result.paymentRequest.requestId)
+  payment.addCommand(
+    addHandoffSurfaceCommand(
+      new Command7("handoff").description(
+        "Render one stored payment request as an integration-ready bundle for external dashboards, agents, or backend ingestion"
       ),
       {
-        ok: true,
-        requestId: result.paymentRequest.requestId,
-        handoff: result.handoff,
-        recommendedCommands: buildPaymentRecommendedCommands(
-          result.paymentRequest,
-          result.executionPlan
-        )
+        handoffCommand: buildPaymentHandoffRecommendedCommand("<request-id>"),
+        workspaceCommand: buildPaymentWorkspaceRecommendedCommand(),
+        feedCommand: buildPaymentFeedRecommendedCommand(),
+        topLevel: false
       }
-    );
-  });
+    )
+  );
   payment.command("parties").description("Render one stored payment request as a stable request parties model").requiredOption("--request-id <id>", "Stored payment request id").action(async (options) => {
     const result = await getStoredPaymentRequestParties(options.requestId);
     printResult(
@@ -17369,6 +17694,8 @@ function buildOperatorSuitePayload(options = {}) {
   const paymentCommand = buildPaymentSubmitRecommendedCommand(walletName);
   const publicPaymentCommand = buildSubmitRecommendedCommand(walletName);
   const publicWorkspaceCommand = buildWorkspaceRecommendedCommand();
+  const publicHandoffCommand = buildHandoffRecommendedCommand("<request-id>");
+  const publicFeedCommand = buildFeedRecommendedCommand();
   const paymasterCommand = buildWorkflowPayRecommendedCommand(walletName, "approval-based");
   const fundingCommand = buildWorkflowFundRecommendedCommand(walletName);
   const nextCommand = buildTopLevelNextRecommendedCommand(void 0, void 0, walletName);
@@ -17599,10 +17926,10 @@ function buildOperatorSuitePayload(options = {}) {
         return [
           publicPaymentCommand,
           buildPaymentNextRecommendedCommand("<request-id>"),
-          buildPaymentApprovalRecommendedCommand("<request-id>"),
+          buildApprovalRecommendedCommand("<request-id>"),
           publicWorkspaceCommand,
-          buildPaymentHandoffRecommendedCommand("<request-id>"),
-          buildPaymentFeedRecommendedCommand()
+          publicHandoffCommand,
+          publicFeedCommand
         ];
       case "inspect-before-acting":
       case "unstick-a-write":
@@ -17760,6 +18087,16 @@ function buildOperatorSuitePayload(options = {}) {
       proofPath: slices[4].proofPath ?? [slices[4].primaryCommand]
     }
   ];
+  const platformLayer = {
+    stage: "local-first-product-shell",
+    productClaim: "flagship pay, Agent Pay request routing, and hosted approval recovery already read like one product shell",
+    flagshipSurface: publicFlagshipCommand,
+    agentPaySurface: `${publicPaymentCommand} -> ${buildApprovalRecommendedCommand("<request-id>")} -> ${publicWorkspaceCommand} -> ${publicHandoffCommand} -> ${publicFeedCommand}`,
+    hostedRecoverySurface: hostedRelayBaselineCommand,
+    proofSurfaceIds: proofPaths.map((entry) => entry.id),
+    nextMaturityTarget: "add one stronger hosted/platform-facing proof surface above the current local-first request workbench",
+    boundary: "local-first by default today; Agent Pay is not yet a hosted multi-tenant control plane"
+  };
   return {
     ok: true,
     summary: {
@@ -17779,6 +18116,7 @@ function buildOperatorSuitePayload(options = {}) {
       recommendedOrder: [flagship.id, ...slices.map((entry) => entry.id)],
       nextAction: flagship.primaryCommand
     },
+    platformLayer,
     ...preflight ? { preflight } : {},
     recommendedJourney,
     proofPaths,
@@ -17797,7 +18135,10 @@ function buildOperatorSuitePayload(options = {}) {
       payment: paymentCommand,
       publicFlagship: publicFlagshipCommand,
       publicPayment: publicPaymentCommand,
+      publicApproval: buildApprovalRecommendedCommand("<request-id>"),
       publicWorkspace: publicWorkspaceCommand,
+      publicHandoff: publicHandoffCommand,
+      publicFeed: publicFeedCommand,
       discovery: discoveryCommand,
       paymaster: paymasterCommand,
       funding: fundingCommand,
@@ -17821,7 +18162,7 @@ function operatorSuiteLines(payload) {
       return entry.supportingCommands;
     }
     return entry.supportingCommands.map(
-      (command) => command === buildPaymentWorkspaceRecommendedCommand() ? payload.recommendedCommands.publicWorkspace ?? command : command
+      (command) => command === buildPaymentApprovalRecommendedCommand("<request-id>") ? payload.recommendedCommands.publicApproval ?? command : command === buildPaymentWorkspaceRecommendedCommand() ? payload.recommendedCommands.publicWorkspace ?? command : command === buildPaymentHandoffRecommendedCommand("<request-id>") ? payload.recommendedCommands.publicHandoff ?? command : command === buildPaymentFeedRecommendedCommand() ? payload.recommendedCommands.publicFeed ?? command : command
     );
   };
   const renderEntryProofPath = (entry) => {
@@ -17835,9 +18176,18 @@ function operatorSuiteLines(payload) {
       if (command === entry.primaryCommand) {
         return payload.recommendedCommands.publicPayment ?? command;
       }
+      if (command === buildPaymentApprovalRecommendedCommand("<request-id>")) {
+        return payload.recommendedCommands.publicApproval ?? command;
+      }
       if (command === buildPaymentWorkspaceRecommendedCommand()) {
         return payload.recommendedCommands.publicWorkspace ?? command;
       }
+      if (command === buildPaymentHandoffRecommendedCommand("<request-id>")) {
+        return payload.recommendedCommands.publicHandoff ?? command;
+      }
+      if (command === buildPaymentFeedRecommendedCommand()) {
+        return payload.recommendedCommands.publicFeed ?? command;
+      }
       return command;
     });
   };
@@ -17901,6 +18251,14 @@ function operatorSuiteLines(payload) {
     ["chain", payload.summary.chain],
     ["stage", payload.summary.stage],
     ["use when", payload.summary.useWhen],
+    ["platform stage", payload.platformLayer.stage],
+    ["platform claim", payload.platformLayer.productClaim],
+    ["platform flagship surface", payload.platformLayer.flagshipSurface],
+    ["platform agent pay surface", payload.platformLayer.agentPaySurface],
+    ["platform hosted recovery surface", payload.platformLayer.hostedRecoverySurface],
+    ["platform proof surfaces", payload.platformLayer.proofSurfaceIds.join(" -> ")],
+    ["platform next maturity", payload.platformLayer.nextMaturityTarget],
+    ["platform boundary", payload.platformLayer.boundary],
     ["entry modes", payload.summary.entryModes.join(" -> ")],
     ["start here journey", payload.summary.startHereJourneyId],
     ["start here", payload.recommendedJourney.publicStartCommand ?? payload.recommendedJourney.startCommand],
@@ -18000,11 +18358,11 @@ function createSuiteCommand() {
       `    ${buildTopLevelPayRecommendedCommand("main")}`,
       `    ${buildSubmitRecommendedCommand("main")}`,
       "    zk-agent payment next --request-id <id>",
-      "    zk-agent payment approval --request-id <id>",
+      `    ${buildApprovalRecommendedCommand("<id>")}`,
       "    zk-agent workspace",
       "    zk-agent payment dashboard",
-      "    zk-agent payment handoff --request-id <id>",
-      "    zk-agent payment feed",
+      `    ${buildHandoffRecommendedCommand("<id>")}`,
+      `    ${buildFeedRecommendedCommand()}`,
       "    zk-agent assets --wallet main",
       `    ${buildTopLevelPayRecommendedCommand("main", "approval-based")}`,
       "    zk-agent workflow fund --wallet main",
@@ -18014,7 +18372,7 @@ function createSuiteCommand() {
       "  Pass `--include-onboarding` when you want setup, doctor, and wallet bootstrap",
       "  guidance in the same packaged readout.",
       "",
-      "  In JSON mode, `summary.catalogView`, `summary.entryModes`,",
+      "  In JSON mode, top-level `platformLayer` plus `summary.catalogView`, `summary.entryModes`,",
       "  `summary.startHereJourneyId`, `summary.journeyOrder`,",
       "  `summary.surfaceOrder`, top-level `recommendedJourney`, top-level",
       "  `proofPaths[]`, top-level `questions[]`, top-level `journeys[]`, top-level `surfaces[]`, `summary.categoryOrder`,",
@@ -18027,14 +18385,14 @@ function createSuiteCommand() {
       "  proof routes: flagship pay, Agent Pay, and hosted approval recovery.",
       "  Stable machine command fields remain scoped; optional additive",
       "  public-read fields may also appear as `publicStartCommand`,",
-      "  `publicProofPath`, `publicFlagship`, `publicPayment`, and",
-      "  `publicWorkspace` when the same payload wants a shorter",
+      "  `publicProofPath`, `publicFlagship`, `publicPayment`, `publicApproval`, and",
+      "  `publicWorkspace`, `publicHandoff`, and `publicFeed` when the same payload wants a shorter",
       "  product-facing command layer without breaking the scoped contract.",
       "  `proofPath` appears selectively on entries and on the top-level",
       "  `recommendedJourney` when one bounded public demo route exists.",
       "  `recommendedCommands.workflowSurface|paymentSurface|discoverySurface|relaySurface`",
       "  expose the direct deeper-surface entry commands while the optional",
-      "  `recommendedCommands.publicFlagship|publicPayment|publicWorkspace`",
+      "  `recommendedCommands.publicFlagship|publicPayment|publicApproval|publicWorkspace|publicHandoff|publicFeed`",
       "  fields expose the shorter public shell."
     ].join("\n")
   ).action((options) => {
@@ -19357,16 +19715,17 @@ function createRelayCommand() {
     [
       "",
       "  Relay surface:",
-      "    Open this layer only when the browser is remote and cannot return to this terminal.",
+      "    Use this layer only when the browser is remote and cannot return to this terminal.",
+      "    Start with `relay baseline`; open `relay inspect` only when you need the raw public-origin, UI, and hosted-readiness fields directly.",
       "    Keep `wallet create|reapprove --await-local` as the default baseline when the browser and terminal are colocated.",
-      "    Use `relay baseline` for the product-style hosted approval summary; use `relay inspect` when you need the lower-level readiness contract fields directly.",
       "",
-      "  Fastest hosted recovery proof path:",
+      "  Remote-browser fallback:",
+      "    existing wallet:",
       "    zk-agent relay baseline --relay-url <url>",
       "    zk-agent wallet reapprove --name main --relay-url <url> --wait-relay --prompt-code",
       "    zk-agent wallet status --name main",
       "",
-      "  If the wallet does not exist yet:",
+      "    no wallet yet:",
       "    zk-agent relay baseline --relay-url <url>",
       "    zk-agent wallet create --relay-url <url> --wait-relay --prompt-code",
       "    zk-agent next",
@@ -19378,11 +19737,7 @@ function createRelayCommand() {
       "    one externally reachable public origin",
       "    one relay host with same-host file persistence",
       "    one same-origin share-link + approval UI surface",
-      "    Do not assume multi-host or load-balanced durability.",
-      "",
-      "  Use `relay baseline` before sending users to a hosted share link when",
-      "  you want the packaged public summary and proof paths first.",
-      "  Use `relay inspect` when the public origin, connector UI, and hosted-readiness contract need direct lower-level inspection."
+      "    Not a multi-host or load-balanced service."
     ].join("\n")
   );
   relay.command("baseline").description(
@@ -20206,6 +20561,10 @@ import { Wallet as ZkSyncWallet } from "zksync-ethers";
 var provider3 = new ZkSyncWalletProvider();
 var NATIVE_TOKEN_DECIMALS = 18;
 var LOCAL_APPROVAL_BODY_LIMIT_BYTES = 512 * 1024;
+var LIVE_RPC_ENV_BY_CHAIN_KEY = {
+  "zksync-era": "ZKSYNC_ERA_RPC_URL",
+  "zksync-sepolia": "ZKSYNC_SEPOLIA_RPC_URL"
+};
 var WALLET_HELP_COMMAND_ORDER = [
   "create",
   "reapprove",
@@ -21093,16 +21452,16 @@ function applyWalletSyncMetadata(wallet, updates) {
   }
   return nextWallet;
 }
-async function readWalletContract(wallet, data) {
-  const result = await provider3.call({
+async function readWalletContract(wallet, data, syncProvider = provider3) {
+  const result = await syncProvider.call({
     chain: wallet.chain,
     to: wallet.walletAddress,
     data
   });
   return result.result === "0x" ? void 0 : result.result;
 }
-async function syncWalletRecord(wallet, profileOverride) {
-  const inspection = await provider3.inspectWallet(wallet);
+async function syncWalletRecord(wallet, profileOverride, syncProvider = provider3) {
+  const inspection = await syncProvider.inspectWallet(wallet);
   const notes = [];
   const syncedAt = (/* @__PURE__ */ new Date()).toISOString();
   const storedProfileId = tryResolveBuiltinProfileId(wallet.smartAccountProfileId);
@@ -21155,7 +21514,11 @@ async function syncWalletRecord(wallet, profileOverride) {
       notes
     };
   }
-  const ownerResult = await readWalletContract(nextWallet, encodeSedLiteOwnerRead());
+  const ownerResult = await readWalletContract(
+    nextWallet,
+    encodeSedLiteOwnerRead(),
+    syncProvider
+  );
   if (!ownerResult) {
     notes.push(`Profile-aware owner read returned empty data for ${profileId}.`);
   } else {
@@ -21164,8 +21527,16 @@ async function syncWalletRecord(wallet, profileOverride) {
     });
   }
   if (profileId === "sed-lite") {
-    const validatorResult = await readWalletContract(nextWallet, encodeSedLiteValidatorRead());
-    const hooksResult = await readWalletContract(nextWallet, encodeSedLiteValidationHooksRead());
+    const validatorResult = await readWalletContract(
+      nextWallet,
+      encodeSedLiteValidatorRead(),
+      syncProvider
+    );
+    const hooksResult = await readWalletContract(
+      nextWallet,
+      encodeSedLiteValidationHooksRead(),
+      syncProvider
+    );
     nextWallet = applyWalletSyncMetadata(nextWallet, {
       validatorAddress: validatorResult ? decodeSedLiteValidatorRead(validatorResult) : void 0,
       validationHookAddresses: hooksResult ? decodeSedLiteValidationHooksRead(hooksResult) : []
@@ -21191,6 +21562,71 @@ async function syncWalletRecord(wallet, profileOverride) {
     notes
   };
 }
+function canAutoSyncApprovedWallet(walletRecord, syncProvider) {
+  if (syncProvider && syncProvider !== provider3) {
+    return { ok: true };
+  }
+  let chainKey = walletRecord.chain;
+  try {
+    chainKey = resolveChain(walletRecord.chain).key;
+  } catch {
+  }
+  const envName = LIVE_RPC_ENV_BY_CHAIN_KEY[chainKey];
+  if (!envName) {
+    return {
+      ok: false,
+      reason: "Automatic post-approval wallet sync was skipped because this chain does not have a recognized RPC env override."
+    };
+  }
+  if (!process.env[envName]?.trim()) {
+    return {
+      ok: false,
+      reason: `Automatic post-approval wallet sync was skipped because ${envName} is not configured.`
+    };
+  }
+  return { ok: true };
+}
+async function tryAutoSyncApprovedWallet(options) {
+  const eligibility = canAutoSyncApprovedWallet(options.walletRecord, options.syncProvider);
+  if (!eligibility.ok) {
+    return {
+      walletRecord: options.walletRecord,
+      sync: {
+        attempted: false,
+        ok: false,
+        notes: eligibility.reason ? [eligibility.reason] : []
+      }
+    };
+  }
+  try {
+    const result = await syncWalletRecord(
+      options.walletRecord,
+      void 0,
+      options.syncProvider ?? provider3
+    );
+    await saveWalletSession(result.wallet);
+    return {
+      walletRecord: result.wallet,
+      sync: {
+        attempted: true,
+        ok: true,
+        syncedAt: result.wallet.syncedAt,
+        profileId: result.profileId,
+        notes: result.notes
+      }
+    };
+  } catch (error) {
+    return {
+      walletRecord: options.walletRecord,
+      sync: {
+        attempted: true,
+        ok: false,
+        notes: [],
+        error: error instanceof Error && error.message ? error.message : "Automatic post-approval wallet sync failed."
+      }
+    };
+  }
+}
 function formatDeploymentStatus(inspection) {
   if (inspection.deploymentStatus === "not-applicable") return "n/a";
   return inspection.deploymentStatus;
@@ -21496,6 +21932,7 @@ function buildWalletApprovalLines(status, requestId, walletRecord) {
     ["account", displayAccountKind(walletRecord)],
     ["chain", `${walletRecord.chain} (${walletRecord.chainId})`],
     ["paymaster", displayPaymasterMode(walletRecord)],
+    ...walletRecord.syncedAt ? [["synced", walletRecord.syncedAt]] : [],
     ...sessionPolicyLines(walletRecord.sessionPayload?.permissions),
     ["next", buildWalletNextRecommendedCommand(walletRecord.walletName)],
     ["status command", buildWalletStatusRecommendedCommand(walletRecord.walletName)]
@@ -22005,9 +22442,14 @@ async function finalizePublishedRelayWalletRequest(options) {
   assertApprovedPayloadMatchesRequest(payload, options.walletRequest);
   const walletRecord = await importApprovedWalletSession(options.walletRequest.walletName, payload);
   await deleteWalletRequest(options.walletRequest.requestId);
+  const synced = await tryAutoSyncApprovedWallet({
+    walletRecord,
+    syncProvider: options.syncProvider
+  });
   return {
     payload,
-    walletRecord
+    walletRecord: synced.walletRecord,
+    sync: synced.sync
   };
 }
 function writeLocalApprovalJson(response, statusCode, payload) {
@@ -22240,11 +22682,16 @@ async function awaitLocalWalletApproval(options) {
       }, timeoutSeconds * 1e3);
     });
     const { walletRecord, payload } = await Promise.race([completion, timeoutPromise]);
-    return {
+    const synced = await tryAutoSyncApprovedWallet({
       walletRecord,
+      syncProvider: options.syncProvider
+    });
+    return {
+      walletRecord: synced.walletRecord,
       payload,
       callbackUrl: callbackUrl.toString(),
-      approvalUrl: approvalUrl.toString()
+      approvalUrl: approvalUrl.toString(),
+      sync: synced.sync
     };
   } finally {
     if (timeoutHandle) {
@@ -22537,9 +22984,10 @@ function createWalletCommand(deps) {
       const relayWaitOptions = resolveRelayWaitOptions(options);
       if (options.awaitLocal) {
         const listenerOptions = resolveLocalApprovalListenerOptions(options);
-        const { walletRecord, payload, callbackUrl, approvalUrl } = await awaitLocalWalletApproval({
+        const { walletRecord, payload, callbackUrl, approvalUrl, sync } = await awaitLocalWalletApproval({
           walletRequest: request2,
           walletName: request2.walletName,
+          syncProvider: resolvedDeps.provider,
           ...listenerOptions
         });
         printResult(
@@ -22556,6 +23004,7 @@ function createWalletCommand(deps) {
             wallet: sanitizeWalletRecord(walletRecord),
             callbackUrl,
             approvalUrl,
+            sync,
             nextAction: buildWalletFollowUpNextAction(walletRecord),
             recommendedCommands: buildWalletFollowUpRecommendedCommands(walletRecord)
           }
@@ -22581,8 +23030,9 @@ function createWalletCommand(deps) {
             )
           });
         }
-        const { payload, walletRecord } = await finalizePublishedRelayWalletRequest({
+        const { payload, walletRecord, sync } = await finalizePublishedRelayWalletRequest({
           walletRequest: request2,
+          syncProvider: resolvedDeps.provider,
           ...relayWaitOptions
         });
         printResult(
@@ -22600,6 +23050,7 @@ function createWalletCommand(deps) {
             wallet: sanitizeWalletRecord(walletRecord),
             relay,
             ...relayOutputAliases(relay),
+            sync,
             nextAction: buildWalletFollowUpNextAction(walletRecord),
             recommendedCommands: buildWalletFollowUpRecommendedCommands(walletRecord)
           }
@@ -22737,9 +23188,10 @@ function createWalletCommand(deps) {
       const relayWaitOptions = resolveRelayWaitOptions(options);
       if (options.awaitLocal) {
         const listenerOptions = resolveLocalApprovalListenerOptions(options);
-        const { walletRecord: approvedWallet, payload, callbackUrl, approvalUrl } = await awaitLocalWalletApproval({
+        const { walletRecord: approvedWallet, payload, callbackUrl, approvalUrl, sync } = await awaitLocalWalletApproval({
           walletRequest: request2,
           walletName: request2.walletName,
+          syncProvider: resolvedDeps.provider,
           ...listenerOptions
         });
         printResult(
@@ -22756,6 +23208,7 @@ function createWalletCommand(deps) {
             wallet: sanitizeWalletRecord(approvedWallet),
             callbackUrl,
             approvalUrl,
+            sync,
             nextAction: buildWalletFollowUpNextAction(approvedWallet),
             recommendedCommands: buildWalletFollowUpRecommendedCommands(approvedWallet)
           }
@@ -22781,8 +23234,9 @@ function createWalletCommand(deps) {
             )
           });
         }
-        const { payload, walletRecord: approvedWallet } = await finalizePublishedRelayWalletRequest({
+        const { payload, walletRecord: approvedWallet, sync } = await finalizePublishedRelayWalletRequest({
           walletRequest: request2,
+          syncProvider: resolvedDeps.provider,
           ...relayWaitOptions
         });
         printResult(
@@ -22800,6 +23254,7 @@ function createWalletCommand(deps) {
             wallet: sanitizeWalletRecord(approvedWallet),
             relay,
             ...relayOutputAliases(relay),
+            sync,
             nextAction: buildWalletFollowUpNextAction(approvedWallet),
             recommendedCommands: buildWalletFollowUpRecommendedCommands(approvedWallet)
           }
@@ -23236,9 +23691,10 @@ function createWalletCommand(deps) {
       const walletRequest = await requireActiveWalletRequest(options.requestId);
       const walletName = options.name || walletRequest.walletName;
       const listenerOptions = resolveLocalApprovalListenerOptions(options);
-      const { walletRecord, payload, callbackUrl, approvalUrl } = await awaitLocalWalletApproval({
+      const { walletRecord, payload, callbackUrl, approvalUrl, sync } = await awaitLocalWalletApproval({
         walletRequest,
         walletName,
+        syncProvider: resolvedDeps.provider,
         ...listenerOptions
       });
       printResult(buildWalletApprovalLines("Wallet request approved via local connector callback", walletRequest.requestId, walletRecord), {
@@ -23249,6 +23705,7 @@ function createWalletCommand(deps) {
         wallet: sanitizeWalletRecord(walletRecord),
         callbackUrl,
         approvalUrl,
+        sync,
         nextAction: buildWalletFollowUpNextAction(walletRecord),
         recommendedCommands: buildWalletFollowUpRecommendedCommands(walletRecord)
       });
@@ -23413,21 +23870,26 @@ function createWalletCommand(deps) {
     assertApprovedPayloadMatchesRequest(payload, walletRequest);
     const walletRecord = await importApprovedWalletSession(walletRequest.walletName, payload);
     await deleteWalletRequest(walletRequest.requestId);
+    const synced = await tryAutoSyncApprovedWallet({
+      walletRecord,
+      syncProvider: resolvedDeps.provider
+    });
     printResult(
       buildWalletApprovalLines(
         options.payload ? "Wallet request approved from connector payload" : "Wallet request approved from encrypted relay payload",
         walletRequest.requestId,
-        walletRecord
+        synced.walletRecord
       ),
       {
         ok: true,
         walletRequestId: walletRequest.requestId,
         request: sanitizeWalletRequestRecord(walletRequest),
         payload: sanitizeSessionPayload(payload),
-        wallet: sanitizeWalletRecord(walletRecord),
+        wallet: sanitizeWalletRecord(synced.walletRecord),
         approvalSource: options.payload ? "payload" : options.encryptedPayload ? "encrypted-payload" : "relay-url",
-        nextAction: buildWalletFollowUpNextAction(walletRecord),
-        recommendedCommands: buildWalletFollowUpRecommendedCommands(walletRecord)
+        sync: synced.sync,
+        nextAction: buildWalletFollowUpNextAction(synced.walletRecord),
+        recommendedCommands: buildWalletFollowUpRecommendedCommands(synced.walletRecord)
       }
     );
   });
@@ -23458,16 +23920,25 @@ function createWalletCommand(deps) {
       const walletName = options.name || walletRequest.walletName;
       const walletRecord = await importApprovedWalletSession(walletName, payload);
       await deleteWalletRequest(walletRequest.requestId);
+      const synced = await tryAutoSyncApprovedWallet({
+        walletRecord,
+        syncProvider: resolvedDeps.provider
+      });
       printResult(
-        buildWalletApprovalLines("Wallet request approved locally", walletRequest.requestId, walletRecord),
+        buildWalletApprovalLines(
+          "Wallet request approved locally",
+          walletRequest.requestId,
+          synced.walletRecord
+        ),
         {
           ok: true,
           walletRequestId: walletRequest.requestId,
           request: sanitizeWalletRequestRecord(walletRequest),
           payload: sanitizeSessionPayload(payload),
-          wallet: sanitizeWalletRecord(walletRecord),
-          nextAction: buildWalletFollowUpNextAction(walletRecord),
-          recommendedCommands: buildWalletFollowUpRecommendedCommands(walletRecord)
+          wallet: sanitizeWalletRecord(synced.walletRecord),
+          sync: synced.sync,
+          nextAction: buildWalletFollowUpNextAction(synced.walletRecord),
+          recommendedCommands: buildWalletFollowUpRecommendedCommands(synced.walletRecord)
         }
       );
     }
@@ -26046,8 +26517,24 @@ function applyWorkflowPayDefaults(options) {
     createCheckpoint: true,
     executeWhenReady: true,
     ensureWalletSession: true,
-    sessionPreset: options.sessionPreset?.trim() || "intent",
-    paymasterMode: options.paymasterMode?.trim() || "approval-based"
+    sessionPreset: options.sessionPreset?.trim() || "intent"
+  };
+}
+async function applyWorkflowPayRuntimeDefaults(options) {
+  const requestedId = options.requestId?.trim();
+  let walletName = options.wallet;
+  if (requestedId) {
+    const checkpoint = await loadWorkflowCheckpoint(requestedId);
+    if (checkpoint?.walletName) {
+      walletName = checkpoint.walletName;
+    }
+  }
+  const wallet = await requireWalletRecord(walletName || "main");
+  const inheritedPaymasterMode = wallet.sessionPayload?.paymaster?.mode || wallet.paymasterMode || "approval-based";
+  return {
+    ...options,
+    wallet: wallet.walletName,
+    paymasterMode: options.paymasterMode?.trim() || inheritedPaymasterMode
   };
 }
 async function executeWorkflowAutoCommand(options, deps = resolveWorkflowCommandDeps(void 0)) {
@@ -26084,7 +26571,10 @@ async function executeWorkflowAutoCommand(options, deps = resolveWorkflowCommand
         findReusableWalletRequest,
         createWalletReapprovalRequest,
         publishWalletRequestToRelay: deps.publishWalletRequestToRelay,
-        awaitLocalWalletApproval,
+        awaitLocalWalletApproval: (options2) => awaitLocalWalletApproval({
+          ...options2,
+          syncProvider: provider4
+        }),
         inspectWorkflowStatus: async (input) => inspectWorkflowStatus(input, {
           provider: provider4,
           defiProvider: defiProvider2
@@ -26711,7 +27201,10 @@ async function inspectWorkflowExecutionState(options, context, deps = resolveWor
       findReusableWalletRequest,
       createWalletReapprovalRequest,
       publishWalletRequestToRelay: deps.publishWalletRequestToRelay,
-      awaitLocalWalletApproval,
+      awaitLocalWalletApproval: (approvalOptions) => awaitLocalWalletApproval({
+        ...approvalOptions,
+        syncProvider: provider4
+      }),
       inspectWorkflowStatus: async (input) => inspectWorkflowStatus(input, {
         provider: provider4,
         defiProvider: defiProvider2
@@ -26864,7 +27357,7 @@ function configureWorkflowPayCommand(command, resolvedDeps, surface) {
     includeLocalApproval: true
   }).action(withWorkflowInputErrorHandling(async (options) => {
     const execution = await executeWorkflowAutoCommand(
-      applyWorkflowPayDefaults(options),
+      await applyWorkflowPayRuntimeDefaults(applyWorkflowPayDefaults(options)),
       resolvedDeps
     );
     await printWorkflowAutoCommandResult(execution, "pay");
@@ -27543,25 +28036,44 @@ function buildDefaultOperatorPathHelpText() {
     "  zkSync-native smart-account and paymaster path centered on sed-lite",
     "  Agent Pay request capture and follow-up surface around the same wallet runtime",
     "",
+    "Best fit:",
+    "  you want wallet and session control to stay local instead of starting with a managed browser product",
+    "  you want a zkSync-native pay and paymaster path instead of a generic multichain wrapper",
+    "  you want Agent Pay request capture and a workbench on the same wallet runtime",
+    "",
     "What makes zk-agent-cli different:",
     "  local-first by default, with hosted approval only as a fallback path",
     "  one zkSync-native path from wallet readiness to paymaster-aware execution",
     "  one Agent Pay layer that stays attached to the same wallet runtime instead of splitting into a separate product",
     "",
+    "Current boundary:",
+    "  hosted relay is a fallback path, not the default onboarding story",
+    "  Agent Pay is a local-first workbench today, not a hosted multi-tenant control plane",
+    "",
+    "First command map:",
+    "  clean machine bootstrap -> zk-agent setup",
+    "  public first touch after setup -> zk-agent start",
+    "  canonical live routing contract -> zk-agent next",
+    "  if config is missing, start and next send you back to setup first",
+    "",
     "Why Agent Pay instead of only direct execution:",
     "  capture one request before or after the write path",
     "  keep a cross-request operator workspace around the same wallet runtime",
     "  export stable handoff and feed views for external agents, dashboards, or backends",
     "  current request ingress: zk-agent submit",
     "  current workbench anchor: zk-agent workspace",
+    "  current single-request export: zk-agent handoff --request-id <id>",
+    "  current export surface: zk-agent feed",
     "",
-    "Start here first:",
+    "First proof from a clean machine:",
     "  zk-agent setup",
     "  zk-agent next",
     "  zk-agent wallet create --await-local",
     "  zk-agent next",
     `  ${buildTopLevelPayRecommendedCommand("main")}`,
-    "  Stop after the first successful workflow pay.",
+    "  Stop after the first successful pay.",
+    "  Approved wallets auto-sync local smart-account metadata when chain reads are available,",
+    "  so the default path does not depend on a separate manual wallet sync.",
     "",
     "Before that first success:",
     "  Ignore suite, payment, and relay unless the CLI points you there or the browser is remote.",
@@ -27572,7 +28084,10 @@ function buildDefaultOperatorPathHelpText() {
     "  pay          -> the wallet is ready and you want the flagship proof path now",
     "  submit       -> you want to capture one Agent Pay request now",
     "  suite        -> wallet readiness is clear and the question is broader than one immediate send",
+    "  approval    -> you need approval readiness for one Agent Pay request",
     "  workspace    -> you already know you need the current Agent Pay workbench anchor",
+    "  handoff      -> you already need the stable single-request Agent Pay export",
+    "  feed         -> you already need the integration-ready cross-request Agent Pay export",
     "  payment      -> execution is no longer the whole story and you need the Agent Pay request layer or workbench",
     "  relay baseline -> the browser is remote and approval must move to the hosted fallback path",
     "",
@@ -27584,10 +28099,10 @@ function buildDefaultOperatorPathHelpText() {
     "  Agent Pay requests:",
     `    ${buildSubmitRecommendedCommand("main")}`,
     "    zk-agent payment next --request-id <id>",
-    "    zk-agent payment approval --request-id <id>",
+    `    ${buildApprovalRecommendedCommand("<id>")}`,
     "    zk-agent workspace",
-    "    zk-agent payment handoff --request-id <id>",
-    "    zk-agent payment feed",
+    "    zk-agent handoff --request-id <id>",
+    "    zk-agent feed",
     "  hosted approval recovery:",
     "    zk-agent relay baseline --relay-url <url>",
     "    zk-agent wallet reapprove --name main --relay-url <url> --wait-relay --prompt-code",
@@ -27596,7 +28111,10 @@ function buildDefaultOperatorPathHelpText() {
     "Open these only when the default path is no longer the whole question:",
     "  zk-agent suite",
     `  ${buildSubmitRecommendedCommand("main")}`,
+    `  ${buildApprovalRecommendedCommand("<id>")}`,
     "  zk-agent workspace",
+    "  zk-agent handoff --request-id <id>",
+    "  zk-agent feed",
     "  zk-agent suite --include-onboarding",
     "  zk-agent doctor",
     "  zk-agent next --request-id <id>",
@@ -27619,12 +28137,15 @@ var ROOT_HELP_COMMAND_ORDER = [
   "next",
   "pay",
   "submit",
+  "approval",
   "doctor",
   "init",
   "wallet",
   "workflow",
   "suite",
   "workspace",
+  "handoff",
+  "feed",
   "payment",
   "assets",
   "balances",
@@ -27669,11 +28190,14 @@ function createProgram() {
   program.addCommand(createNextCommand());
   program.addCommand(createPayCommand());
   program.addCommand(createSubmitCommand());
+  program.addCommand(createApprovalCommand());
   program.addCommand(createDoctorCommand());
   program.addCommand(createAgentCommand());
   program.addCommand(createDefaultsCommand());
   program.addCommand(createSuiteCommand());
   program.addCommand(createWorkspaceCommand());
+  program.addCommand(createHandoffCommand());
+  program.addCommand(createFeedCommand());
   program.addCommand(createPaymentCommand());
   program.addCommand(createTokensCommand());
   program.addCommand(createResolveTokenCommand());