zk-agent-cli 0.1.0-beta.8 → 0.1.0-rc.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command11, CommanderError } from "commander";
+import { Command as Command12, CommanderError } from "commander";
 import { config as loadEnv } from "dotenv";
 
 // src/commands/operations.ts
@@ -7745,6 +7745,71 @@ function formatHumanErrorMessage(error) {
   return lines.join("\n");
 }
 
+// src/lib/discovery-summary.ts
+function createEmptyDiscoverySourceCounts() {
+  return {
+    localDeployments: 0,
+    tokenDirectory: 0,
+    unknown: 0
+  };
+}
+function createEmptyDiscoveryRoleCounts() {
+  return Object.fromEntries(
+    REGISTRY_TOKEN_ROLES.map((role) => [role, 0])
+  );
+}
+function summarizeDiscoveryEntrySources(entries) {
+  const counts = createEmptyDiscoverySourceCounts();
+  for (const entry of entries) {
+    if (entry.source === "local-deployments") {
+      counts.localDeployments += 1;
+      continue;
+    }
+    if (entry.source === "token-directory") {
+      counts.tokenDirectory += 1;
+      continue;
+    }
+    counts.unknown += 1;
+  }
+  return counts;
+}
+function summarizeDiscoveryRoleMatches(entries) {
+  const counts = createEmptyDiscoveryRoleCounts();
+  for (const entry of entries) {
+    for (const match of entry.defaultsRegistryMatches || []) {
+      counts[match.role] += 1;
+    }
+  }
+  return counts;
+}
+function countCurrentValidatedDefaultEntries(entries) {
+  return entries.filter(
+    (entry) => (entry.defaultsRegistryMatches || []).some((match) => match.isCurrentValidatedDefault)
+  ).length;
+}
+function listUniqueDiscoveryChains(entries) {
+  return [...new Set(
+    entries.map((entry) => entry.chainKey?.trim()).filter((value) => Boolean(value))
+  )];
+}
+function firstDiscoverySymbol(entries) {
+  return entries.find((entry) => entry.symbol?.trim())?.symbol?.trim() || null;
+}
+function firstDiscoverySource(entries) {
+  if (entries.length === 0) return null;
+  return entries[0]?.source || "unknown";
+}
+function summarizeTokenRegistrySources(sources) {
+  return sources.map((source) => ({
+    id: source.id,
+    enabled: source.enabled,
+    exists: source.exists
+  }));
+}
+function findNativeBalance(balances) {
+  return balances.find((balance) => balance.type === "native") || null;
+}
+
 // src/lib/recommended-commands.ts
 function appendPaymasterMode(command, paymasterMode) {
   if (!paymasterMode || paymasterMode === "none") {
@@ -7765,13 +7830,61 @@ function buildWalletCreateRecommendedCommand() {
 function buildRelayInspectRecommendedCommand(relayUrl = "<url>") {
   return `zk-agent relay inspect --relay-url ${relayUrl}`;
 }
-function buildWalletCreateRemoteRecommendedCommand(relayUrl = "<url>", paymasterMode, walletName = "main", accountKind = "smart-account") {
-  const command = [
+function inferSessionHours(sessionPolicies, requestCreatedAt) {
+  const expiresAt = sessionPolicies?.expiresAt;
+  if (!expiresAt || !requestCreatedAt) return null;
+  const createdAtMs = Date.parse(requestCreatedAt);
+  const expiresAtMs = Date.parse(expiresAt);
+  if (!Number.isFinite(createdAtMs) || !Number.isFinite(expiresAtMs) || expiresAtMs <= createdAtMs) {
+    return null;
+  }
+  const hours = (expiresAtMs - createdAtMs) / (60 * 60 * 1e3);
+  if (!Number.isFinite(hours) || hours <= 0) return null;
+  const rounded = Math.round(hours * 1e3) / 1e3;
+  if (Math.abs(rounded - 24) < 5e-4) {
+    return null;
+  }
+  return Number.isInteger(rounded) ? String(rounded) : String(rounded).replace(/(?:\.0+|(\.\d*?)0+)$/, "$1");
+}
+function appendSessionPolicyFlags(commandParts, options) {
+  const sessionHours = inferSessionHours(options?.sessionPolicies, options?.requestCreatedAt);
+  if (sessionHours) {
+    commandParts.push(`--session-hours ${sessionHours}`);
+  }
+  const transfers = options?.sessionPolicies?.transfers;
+  if (Array.isArray(transfers)) {
+    if (transfers.length === 0) {
+      commandParts.push("--disallow-transfers");
+    } else {
+      for (const policy of transfers) {
+        if (policy?.to) {
+          commandParts.push(`--allow-transfer-to ${policy.to}`);
+        }
+      }
+    }
+  }
+  const contractCalls = options?.sessionPolicies?.contractCalls;
+  if (Array.isArray(contractCalls)) {
+    if (contractCalls.length === 0) {
+      commandParts.push("--disallow-contract-calls");
+    } else {
+      for (const policy of contractCalls) {
+        if (policy?.address) {
+          commandParts.push(`--allow-contract ${policy.address}`);
+        }
+      }
+    }
+  }
+}
+function buildWalletCreateRemoteRecommendedCommand(relayUrl = "<url>", paymasterMode, walletName = "main", accountKind = "smart-account", options) {
+  const commandParts = [
     "zk-agent wallet create",
     walletName !== "main" ? `--name ${walletName}` : "",
-    accountKind !== "smart-account" ? `--account-kind ${accountKind}` : "",
-    `--relay-url ${relayUrl} --wait-relay --prompt-code`
-  ].filter(Boolean).join(" ");
+    accountKind !== "smart-account" ? `--account-kind ${accountKind}` : ""
+  ].filter(Boolean);
+  appendSessionPolicyFlags(commandParts, options);
+  commandParts.push(`--relay-url ${relayUrl} --wait-relay --prompt-code`);
+  const command = commandParts.join(" ");
   return appendPaymasterMode(command, paymasterMode);
 }
 function buildWalletListRecommendedCommand() {
@@ -7780,6 +7893,9 @@ function buildWalletListRecommendedCommand() {
 function buildWalletStatusRecommendedCommand(walletName) {
   return `zk-agent wallet status --name ${walletName}`;
 }
+function buildWalletSignerShowRecommendedCommand(walletName) {
+  return `zk-agent wallet signer show --name ${walletName}`;
+}
 function buildWalletSignerAttachRecommendedCommand(walletName, privateKeyRef = "<hex>") {
   return `zk-agent wallet signer attach --name ${walletName} --private-key ${privateKeyRef}`;
 }
@@ -7836,8 +7952,11 @@ function buildDiscoveryRecommendedCommands(input) {
 function buildWalletReapproveRecommendedCommand(walletName) {
   return `zk-agent wallet reapprove --name ${walletName} --await-local`;
 }
-function buildWalletReapproveRemoteRecommendedCommand(walletName, relayUrl = "<url>") {
-  return `zk-agent wallet reapprove --name ${walletName} --relay-url ${relayUrl} --wait-relay --prompt-code`;
+function buildWalletReapproveRemoteRecommendedCommand(walletName, relayUrl = "<url>", options) {
+  const commandParts = [`zk-agent wallet reapprove --name ${walletName}`];
+  appendSessionPolicyFlags(commandParts, options);
+  commandParts.push(`--relay-url ${relayUrl} --wait-relay --prompt-code`);
+  return commandParts.join(" ");
 }
 function buildWalletNextRecommendedCommand(walletName) {
   return `zk-agent wallet next --name ${walletName}`;
@@ -9181,6 +9300,27 @@ function linesForMultiBalances(result) {
   }
   return lines;
 }
+function buildAssetsDiscoverySummary(result) {
+  const nativeBalance = findNativeBalance(result.balances);
+  const ownedTokenSymbols = (result.ownedTokenRegistry?.entries || []).map((entry) => entry.symbol?.trim()).filter((value) => Boolean(value));
+  return {
+    walletName: result.walletName,
+    chain: result.chain,
+    chainId: result.chainId,
+    assetCount: result.balances.length,
+    nativeAssetSymbol: nativeBalance?.symbol || null,
+    nativeAssetBalance: nativeBalance?.balance || null,
+    ownedTokenCount: result.ownedTokenRegistry?.entryCount || 0,
+    primaryOwnedTokenSymbol: firstDiscoverySymbol(result.ownedTokenRegistry?.entries || []),
+    ownedTokenSymbols,
+    ownedTokenSourceCounts: result.ownedTokenRegistry?.summary.sourceCounts || null,
+    ownedBridgeMappingCounts: result.ownedTokenRegistry?.summary.bridgeMappingCounts || null,
+    ownedRegistryRoleCounts: result.ownedTokenRegistry?.summary.registryRoleCounts || null
+  };
+}
+function buildBalancesDiscoverySummary(result) {
+  return buildAssetsDiscoverySummary(result);
+}
 function withPaymasterOptions(command) {
   return command.option("--paymaster-mode <mode>", "none, sponsored, or approval-based").option("--paymaster-address <address>", "Explicit paymaster contract address override").option("--paymaster-token <address>", "ERC-20 token address for approval-based paymaster mode");
 }
@@ -9240,7 +9380,23 @@ function createBalancesCommand(deps) {
       provider: resolvedDeps.provider,
       ownedTokens: options.ownedTokens
     });
-    printResult(linesForSingleBalances(payload), { ok: true, ...payload });
+    const discoverySummary = options.ownedTokens && "ownedTokenRegistry" in payload ? buildBalancesDiscoverySummary(payload) : void 0;
+    const recommendedCommands = options.ownedTokens ? buildDiscoveryRecommendedCommands({
+      walletName,
+      chain: payload.chain
+    }) : void 0;
+    printResult(
+      [
+        ...linesForSingleBalances(payload),
+        ...recommendedCommands ? workflowFollowupLines(recommendedCommands) : []
+      ],
+      {
+        ok: true,
+        ...discoverySummary ? { discoverySummary } : {},
+        ...recommendedCommands ? { recommendedCommands } : {},
+        ...payload
+      }
+    );
   });
 }
 function createAssetsCommand(deps) {
@@ -9279,9 +9435,12 @@ function createAssetsCommand(deps) {
       chain: payload.chain,
       includeAssets: false
     });
+    const discoverySummary = buildAssetsDiscoverySummary(
+      payload
+    );
     printResult(
       [...linesForSingleBalances(payload), ...workflowFollowupLines(recommendedCommands)],
-      { ok: true, recommendedCommands, ...payload }
+      { ok: true, discoverySummary, recommendedCommands, ...payload }
     );
   });
 }
@@ -9961,12 +10120,43 @@ function createPlannedCommands() {
 
 // src/commands/setup.ts
 import { Command as Command2 } from "commander";
+
+// src/lib/onboarding-summary.ts
+function buildOnboardingSummary(input) {
+  return {
+    stage: input.stage,
+    baseline: "local-first",
+    localOnly: input.localOnly,
+    configExists: input.configExists,
+    walletExists: input.walletExists ?? null,
+    approvalReady: input.approvalReady ?? null,
+    localExecutionKeyStored: input.localExecutionKeyStored ?? null,
+    defaultChain: input.defaultChain ?? null,
+    connectorUrl: input.connectorUrl ?? null,
+    relayUrl: input.relayUrl ?? null,
+    nextAction: input.nextAction ?? null,
+    notes: [...input.notes ?? []]
+  };
+}
+function onboardingSummaryLines(summary) {
+  return [
+    ["baseline", summary.baseline],
+    ["local only", summary.localOnly ? "yes" : "no"]
+  ];
+}
+
+// src/commands/setup.ts
 function buildSetupHelpText() {
   return [
     "",
     "What setup does:",
     "  Writes the local default chain and connector URL used by the first-run path.",
     "",
+    "Validated first-run baseline:",
+    "  Default chain:   zksync-sepolia",
+    "  Connector URL:   http://localhost:4444",
+    "  Override --default-chain or --connector-url only when you intentionally deviate from that path.",
+    "",
     "After setup, stay on the canonical local-first path:",
     "  zk-agent next",
     "  zk-agent wallet create --await-local",
@@ -9983,7 +10173,7 @@ function buildSetupHelpText() {
   ].join("\n");
 }
 function createInitCommand() {
-  return new Command2("init").alias("setup").description("Initialize local zk-agent configuration for the default operator path").addHelpText("after", buildSetupHelpText()).option("--default-chain <chain>", "Default chain key", "zksync-era").option("--connector-url <url>", "Connector UI base URL", "http://localhost:4444").option("--force", "Overwrite an existing config", false).action(async (options) => {
+  return new Command2("init").alias("setup").description("Initialize local zk-agent configuration for the validated first-run operator path").addHelpText("after", buildSetupHelpText()).option("--default-chain <chain>", "Default chain key", "zksync-sepolia").option("--connector-url <url>", "Connector UI base URL", "http://localhost:4444").option("--force", "Overwrite an existing config", false).action(async (options) => {
     const recommendedCommands = {
       next: buildTopLevelNextRecommendedCommand(),
       inspectDefaults: buildDefaultsRecommendedCommand(),
@@ -9994,9 +10184,22 @@ function createInitCommand() {
     };
     const existing = await loadProjectConfig();
     if (existing && !options.force) {
+      const onboardingSummary2 = buildOnboardingSummary({
+        stage: "wallet-bootstrap",
+        localOnly: true,
+        configExists: true,
+        defaultChain: existing.defaultChain,
+        connectorUrl: existing.connectorUrl,
+        nextAction: recommendedCommands.next,
+        notes: [
+          "Setup did not overwrite the existing local defaults.",
+          "Run zk-agent next so the CLI can choose wallet bootstrap or workflow follow-up from the current local state."
+        ]
+      });
       printResult(
         [
           ["status", "Config already exists. Re-run with --force to overwrite."],
+          ...onboardingSummaryLines(onboardingSummary2),
           ["default chain", existing.defaultChain],
           ["connector", existing.connectorUrl],
           ["next", recommendedCommands.next],
@@ -10010,22 +10213,36 @@ function createInitCommand() {
           ok: true,
           message: "Config already exists. Re-run with --force to overwrite.",
           config: existing,
+          onboardingSummary: onboardingSummary2,
           recommendedCommands
         }
       );
       return;
     }
     const config = {
-      defaultChain: options.defaultChain || "zksync-era",
+      defaultChain: options.defaultChain || "zksync-sepolia",
       connectorUrl: options.connectorUrl || "http://localhost:4444",
       provider: "zksync-sso",
       createdAt: existing?.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     await saveProjectConfig(config);
+    const onboardingSummary = buildOnboardingSummary({
+      stage: "wallet-bootstrap",
+      localOnly: true,
+      configExists: true,
+      defaultChain: config.defaultChain,
+      connectorUrl: config.connectorUrl,
+      nextAction: recommendedCommands.next,
+      notes: [
+        "Setup only writes local defaults and does not inspect wallet state.",
+        "Stay on zk-agent next so the product entrypoint can decide between wallet bootstrap and workflow guidance."
+      ]
+    });
     printResult(
       [
         ["status", "Config saved"],
+        ...onboardingSummaryLines(onboardingSummary),
         ["default chain", config.defaultChain],
         ["connector", config.connectorUrl],
         ["next", recommendedCommands.next],
@@ -10035,7 +10252,7 @@ function createInitCommand() {
         ["create wallet (remote)", recommendedCommands.createWalletRemote],
         ["after approval", recommendedCommands.afterWalletApproval]
       ],
-      { ok: true, config, recommendedCommands }
+      { ok: true, config, onboardingSummary, recommendedCommands }
     );
   });
 }
@@ -10399,16 +10616,50 @@ function agentProfileLines(summary) {
 }
 
 // src/lib/wallet-next.ts
-function buildWalletNextRecommendedCommands(walletName, summary) {
+function buildWalletNextRecommendedCommands(walletName, summary, paymasterMode) {
   return {
     discoverAssets: buildAssetsRecommendedCommand(walletName),
     discoverOwnedTokens: buildOwnedTokensRecommendedCommand(walletName),
+    ...paymasterMode === "approval-based" ? {
+      discoverPaymasterTokens: buildPaymasterFeeTokensRecommendedCommand(summary.chain),
+      inspectPaymasterToken: buildPaymasterFeeTokenResolveRecommendedCommand(summary.chain)
+    } : {},
     discoverTokens: buildTokensRecommendedCommand(summary.chain),
     inspectToken: buildResolveTokenRecommendedCommand(summary.chain),
     walletStatus: buildWalletStatusRecommendedCommand(walletName),
     ...summary.recommendedCommand ? { nextAction: summary.recommendedCommand } : {}
   };
 }
+function workflowIntentSupportsTokenDiscovery(intent) {
+  return intent === "send-token" || intent === "swap" || intent === "bridge" || intent === "deposit" || intent === "withdraw";
+}
+function buildWalletTokenDiscoverySummary(input) {
+  if (!input.recommendedCommands) {
+    return void 0;
+  }
+  const hasTokenDiscovery = Boolean(input.recommendedCommands.discoverAssets) || Boolean(input.recommendedCommands.discoverOwnedTokens) || Boolean(input.recommendedCommands.discoverTokens) || Boolean(input.recommendedCommands.inspectToken) || Boolean(input.recommendedCommands.discoverPaymasterTokens) || Boolean(input.recommendedCommands.inspectPaymasterToken);
+  if (!hasTokenDiscovery) {
+    return void 0;
+  }
+  return {
+    walletName: input.walletName,
+    chain: input.chain,
+    intent: input.intent || null,
+    nextAction: input.nextAction || null,
+    paymasterMode: input.paymasterMode || null,
+    tokenizedIntent: workflowIntentSupportsTokenDiscovery(input.intent),
+    includesAssetDiscovery: Boolean(input.recommendedCommands.discoverAssets),
+    includesOwnedTokenDiscovery: Boolean(input.recommendedCommands.discoverOwnedTokens),
+    includesChainTokenDiscovery: Boolean(input.recommendedCommands.discoverTokens),
+    includesDirectTokenInspection: Boolean(input.recommendedCommands.inspectToken),
+    includesPaymasterTokenDiscovery: Boolean(
+      input.recommendedCommands.discoverPaymasterTokens
+    ),
+    includesPaymasterTokenInspection: Boolean(
+      input.recommendedCommands.inspectPaymasterToken
+    )
+  };
+}
 function walletNextLines(summary) {
   const lines = [
     ["wallet", summary.walletName],
@@ -10443,7 +10694,7 @@ var defaultProvider = new ZkSyncWalletProvider();
 var defaultDefiProvider = new ZkSyncDefiProvider({
   walletWriter: defaultProvider
 });
-function workflowIntentSupportsTokenDiscovery(intent) {
+function workflowIntentSupportsTokenDiscovery2(intent) {
   return intent === "send-token" || intent === "swap" || intent === "bridge" || intent === "deposit" || intent === "withdraw";
 }
 function buildTopLevelWorkflowRecommendedCommands(input) {
@@ -10457,7 +10708,7 @@ function buildTopLevelWorkflowRecommendedCommands(input) {
     delete: buildWorkflowDeleteRecommendedCommand(input.requestId),
     walletStatus: buildWalletStatusRecommendedCommand(input.walletName),
     ...input.nextAction ? { nextAction: input.nextAction } : {},
-    ...workflowIntentSupportsTokenDiscovery(input.intent) ? {
+    ...workflowIntentSupportsTokenDiscovery2(input.intent) ? {
       discoverAssets: buildAssetsRecommendedCommand(input.walletName),
       discoverOwnedTokens: buildOwnedTokensRecommendedCommand(input.walletName),
       discoverTokens: buildTokensRecommendedCommand(input.chain),
@@ -10485,17 +10736,38 @@ function buildSetupCommand() {
 function buildTopLevelNextRecommendedCommand2(requestId) {
   return requestId ? `zk-agent next --request-id ${requestId}` : "zk-agent next";
 }
+function buildTopLevelWorkflowSummary(result, nextCommand) {
+  return {
+    status: result.status,
+    readyForGoal: result.readyForGoal,
+    nextCommand,
+    blockingActionIds: result.blockingActionIds,
+    fundingProgress: result.fundingProgress ? {
+      kind: result.fundingProgress.kind,
+      txHash: result.fundingProgress.txHash,
+      status: result.fundingProgress.status,
+      terminal: result.fundingProgress.terminal,
+      finalized: result.fundingProgress.finalized
+    } : void 0
+  };
+}
 function appendPaymasterMode2(command, paymasterMode) {
   if (!paymasterMode) return command;
   return `${command} --paymaster-mode ${paymasterMode}`;
 }
-function topLevelNextLines(scope, lines) {
-  return [["scope", scope], ...lines];
+function topLevelNextLines(scope, lines, onboardingSummary) {
+  return [
+    ["scope", scope],
+    ...onboardingSummary ? onboardingSummaryLines(onboardingSummary) : [],
+    ...lines
+  ];
 }
 function buildNextHelpText() {
   return [
     "",
     "Use `next` as the product entrypoint:",
+    "  Stay on `next` until it points you at a wallet-specific or workflow-specific blocker.",
+    "",
     "  Fresh local-first routing:",
     "    zk-agent setup",
     "    zk-agent next",
@@ -10507,6 +10779,8 @@ function buildNextHelpText() {
     "    zk-agent wallet create --relay-url <url> --wait-relay --prompt-code",
     "    zk-agent next",
     "",
+    "  If setup has not run yet, `next` will send you back to `zk-agent setup` first.",
+    "",
     "  Continue a stored workflow checkpoint:",
     "    zk-agent next --request-id <id>",
     "",
@@ -10516,6 +10790,9 @@ function buildNextHelpText() {
     "  Switch to the hosted remote-approval path only when the browser is not colocated:",
     "    zk-agent wallet --help",
     "",
+    "  Use `wallet --help` when you already know the blocker is wallet-specific:",
+    "    zk-agent wallet next --name main",
+    "",
     "  Stay on the workflow layer only when you already have an explicit workflow or checkpoint:",
     "    zk-agent workflow next --request-id <id>"
   ].join("\n");
@@ -10565,6 +10842,14 @@ function createNextCommand(deps) {
         intent: result.intent,
         paymasterMode: extractCheckpointPaymasterMode(updatedCheckpoint)
       });
+      const tokenDiscoverySummary2 = buildWalletTokenDiscoverySummary({
+        walletName: wallet2.walletName,
+        chain: result.plan.chain,
+        intent: result.intent,
+        nextAction: nextCommand2,
+        paymasterMode: extractCheckpointPaymasterMode(updatedCheckpoint),
+        recommendedCommands: recommendedCommands2
+      });
       const workflowAgentProfile = await loadAgentIdentitySummary(wallet2.walletName);
       const agentFollowup2 = buildAgentFollowup(workflowAgentProfile, {
         walletName: wallet2.walletName,
@@ -10597,8 +10882,10 @@ function createNextCommand(deps) {
           nextCommand: nextCommand2,
           agentProfile: workflowAgentProfile,
           agentFollowup: agentFollowup2,
+          summary: buildTopLevelWorkflowSummary(result, nextCommand2),
           result,
           checkpoint: updatedCheckpoint,
+          tokenDiscoverySummary: tokenDiscoverySummary2,
           recommendedCommands: recommendedCommands2
         }
       );
@@ -10611,6 +10898,17 @@ function createNextCommand(deps) {
         afterSetup: buildTopLevelNextRecommendedCommand2(),
         inspectDefaults: buildDefaultsRecommendedCommand()
       };
+      const onboardingSummary2 = buildOnboardingSummary({
+        stage: "setup",
+        localOnly: true,
+        configExists: false,
+        walletExists: false,
+        nextAction: recommendedCommands2.setup,
+        notes: [
+          "No local config was found, so setup is still the first required onboarding step.",
+          "This scope is local-only and does not require live RPC reads."
+        ]
+      });
       printResult(
         topLevelNextLines("setup", [
           ["status", "No local config found"],
@@ -10619,12 +10917,13 @@ function createNextCommand(deps) {
           ["next", recommendedCommands2.setup],
           ["after setup", recommendedCommands2.afterSetup],
           ["inspect defaults", recommendedCommands2.inspectDefaults]
-        ]),
+        ], onboardingSummary2),
         {
           ok: true,
           scope: "setup",
           status: "action-required",
           nextCommand: recommendedCommands2.setup,
+          onboardingSummary: onboardingSummary2,
           agentProfile,
           agentFollowup: defaultAgentFollowup,
           recommendedCommands: recommendedCommands2
@@ -10647,6 +10946,19 @@ function createNextCommand(deps) {
         afterApproval: appendPaymasterMode2(buildTopLevelNextRecommendedCommand2(), paymasterMode),
         inspectDefaults: buildDefaultsRecommendedCommand()
       };
+      const onboardingSummary2 = buildOnboardingSummary({
+        stage: "wallet-bootstrap",
+        localOnly: true,
+        configExists: true,
+        walletExists: false,
+        defaultChain: config.defaultChain,
+        connectorUrl: config.connectorUrl,
+        nextAction: recommendedCommands2.createWallet,
+        notes: [
+          "Config exists, but no saved wallet record was found for this name yet.",
+          "Use the remote approval fallback only when the browser is not colocated with this terminal."
+        ]
+      });
       printResult(
         topLevelNextLines("wallet-bootstrap", [
           ["status", `Wallet not found: ${walletName}`],
@@ -10659,13 +10971,14 @@ function createNextCommand(deps) {
           ["remote fallback", recommendedCommands2.createWalletRemote],
           ["after approval", recommendedCommands2.afterApproval],
           ["inspect defaults", recommendedCommands2.inspectDefaults]
-        ]),
+        ], onboardingSummary2),
         {
           ok: true,
           scope: "wallet-bootstrap",
           walletName,
           config,
           nextCommand: recommendedCommands2.createWallet,
+          onboardingSummary: onboardingSummary2,
           agentProfile,
           agentFollowup: defaultAgentFollowup,
           recommendedCommands: recommendedCommands2
@@ -10701,6 +11014,27 @@ function createNextCommand(deps) {
       paymasterMode
     );
     const nextCommand = summary.recommendedCommand || workflowPay;
+    const onboardingSummary = buildOnboardingSummary({
+      stage: inspection.approvalReady && inspection.localExecutionKeyStored ? "wallet-ready" : "wallet-recovery",
+      localOnly: false,
+      configExists: true,
+      walletExists: true,
+      approvalReady: inspection.approvalReady,
+      localExecutionKeyStored: inspection.localExecutionKeyStored,
+      defaultChain: config.defaultChain,
+      connectorUrl: config.connectorUrl,
+      nextAction: nextCommand,
+      notes: !inspection.approvalReady ? [
+        "Wallet metadata exists, but approved session metadata is still missing.",
+        "Top-level next returns to live workflow guidance after wallet approval is restored."
+      ] : !inspection.localExecutionKeyStored ? [
+        "Approved session metadata exists, but no local execution signer is stored yet.",
+        "Top-level next returns to live workflow guidance after the signer is attached."
+      ] : [
+        "Wallet approval and local signer state are present.",
+        "Top-level next also inspects live deployment and balance state before recommending the workflow step."
+      ]
+    });
     const agentFollowup = buildAgentFollowup(agentProfile, {
       walletName: wallet.walletName,
       walletExists: true
@@ -10721,6 +11055,13 @@ function createNextCommand(deps) {
       nextAction: nextCommand,
       inspectDefaults: buildDefaultsRecommendedCommand()
     };
+    const tokenDiscoverySummary = buildWalletTokenDiscoverySummary({
+      walletName: wallet.walletName,
+      chain: wallet.chain,
+      nextAction: nextCommand,
+      paymasterMode,
+      recommendedCommands
+    });
     printResult(
       topLevelNextLines("wallet", [
         ...walletNextLines(summary),
@@ -10734,16 +11075,18 @@ function createNextCommand(deps) {
         ...recommendedCommands.inspectPaymasterToken ? [["inspect paymaster token", recommendedCommands.inspectPaymasterToken]] : [],
         ["inspect token", recommendedCommands.inspectToken],
         ["inspect defaults", recommendedCommands.inspectDefaults]
-      ]),
+      ], onboardingSummary),
       {
         ok: true,
         scope: "wallet",
         walletName: wallet.walletName,
+        onboardingSummary,
         agentProfile,
         agentFollowup,
         inspection,
         summary,
         nextCommand,
+        tokenDiscoverySummary,
         recommendedCommands
       }
     );
@@ -10756,8 +11099,418 @@ function parsePaymasterMode(value) {
   throw new Error(`Unsupported paymaster mode: ${value}`);
 }
 
-// src/commands/agent.ts
+// src/commands/doctor.ts
 import { Command as Command4 } from "commander";
+function buildDoctorHelpText() {
+  return [
+    "",
+    "Use `doctor` when local state is unclear:",
+    "  zk-agent doctor",
+    "  zk-agent doctor --wallet main",
+    "  zk-agent doctor --wallet main --relay-url https://relay.example.com",
+    "",
+    "Default behavior:",
+    "  Inspects saved config, local wallet approval metadata, local signer state,",
+    "  and the shortest next command without requiring live RPC reads.",
+    "  Run this before guessing whether the blocker is setup, wallet approval, or local signer state.",
+    "",
+    "Remote-browser recovery path:",
+    "  Pass --relay-url when you want the remote approval fallback commands",
+    "  to use a concrete relay URL instead of a placeholder."
+  ].join("\n");
+}
+function summarizeLocalWalletState(wallet) {
+  const localExecutionPrivateKey = resolveLocalExecutionPrivateKey(wallet);
+  return {
+    exists: true,
+    walletName: wallet.walletName,
+    walletAddress: wallet.walletAddress,
+    chain: wallet.chain,
+    chainId: wallet.chainId,
+    accountKind: wallet.accountKind || wallet.sessionPayload?.account?.kind || "smart-account",
+    smartAccountProfileId: wallet.smartAccountProfileId || null,
+    syncedAt: wallet.syncedAt || null,
+    approvalReady: Boolean(wallet.sessionPayload),
+    localExecutionKeyStored: Boolean(localExecutionPrivateKey),
+    legacySessionKeyStored: Boolean(wallet.sessionPayload?.sessionPrivateKey),
+    signerType: wallet.localExecutionAuthority?.signerType || wallet.sessionPayload?.account?.signerType || null,
+    signerAddress: wallet.localExecutionAuthority?.signerAddress || deriveLocalExecutionSignerAddress(localExecutionPrivateKey) || null,
+    signerSource: wallet.localExecutionAuthority?.source || (wallet.sessionPayload?.sessionPrivateKey ? "legacy-session-payload" : null)
+  };
+}
+function buildSetupRecommendedCommands() {
+  return {
+    setup: "zk-agent setup",
+    next: buildTopLevelNextRecommendedCommand(),
+    inspectDefaults: buildDefaultsRecommendedCommand()
+  };
+}
+function buildWalletBootstrapRecommendedCommands(walletName, relayUrl) {
+  return {
+    next: buildTopLevelNextRecommendedCommand(),
+    inspectDefaults: buildDefaultsRecommendedCommand(),
+    createWallet: buildWalletCreateRecommendedCommand(),
+    relayInspect: buildRelayInspectRecommendedCommand(relayUrl),
+    createWalletRemote: buildWalletCreateRemoteRecommendedCommand(relayUrl, void 0, walletName)
+  };
+}
+function buildWalletRecoveryRecommendedCommands(wallet, relayUrl) {
+  const shared = {
+    next: buildTopLevelNextRecommendedCommand(),
+    walletStatus: buildWalletStatusRecommendedCommand(wallet.walletName),
+    walletNext: buildWalletNextRecommendedCommand(wallet.walletName),
+    signerShow: buildWalletSignerShowRecommendedCommand(wallet.walletName),
+    relayInspect: buildRelayInspectRecommendedCommand(relayUrl),
+    reapproveRemote: buildWalletReapproveRemoteRecommendedCommand(wallet.walletName, relayUrl)
+  };
+  if (!wallet.approvalReady) {
+    return {
+      ...shared,
+      reapprove: buildWalletReapproveRecommendedCommand(wallet.walletName)
+    };
+  }
+  return {
+    ...shared,
+    attachSigner: buildWalletSignerAttachRecommendedCommand(wallet.walletName),
+    reapprove: buildWalletReapproveRecommendedCommand(wallet.walletName)
+  };
+}
+function buildWalletReadyRecommendedCommands(wallet) {
+  return {
+    next: buildTopLevelNextRecommendedCommand(),
+    walletStatus: buildWalletStatusRecommendedCommand(wallet.walletName),
+    walletNext: buildWalletNextRecommendedCommand(wallet.walletName),
+    workflowPay: buildWorkflowPayRecommendedCommand(wallet.walletName),
+    inspectDefaults: buildDefaultsRecommendedCommand()
+  };
+}
+function buildDoctorResult(options) {
+  if (!options.config) {
+    const recommendedCommands2 = buildSetupRecommendedCommands();
+    const onboardingSummary2 = buildOnboardingSummary({
+      stage: "setup",
+      localOnly: true,
+      configExists: false,
+      walletExists: Boolean(options.wallet),
+      approvalReady: options.wallet?.approvalReady ?? null,
+      localExecutionKeyStored: options.wallet?.localExecutionKeyStored ?? null,
+      relayUrl: options.relayUrl || null,
+      nextAction: recommendedCommands2.setup,
+      notes: [
+        "Local config is missing, so the canonical operator path should start with setup.",
+        "Doctor is local-only by default and does not require live RPC reads."
+      ]
+    });
+    return {
+      scope: "setup",
+      nextAction: recommendedCommands2.setup,
+      onboardingSummary: onboardingSummary2,
+      summary: {
+        stage: "setup",
+        configExists: false,
+        walletExists: Boolean(options.wallet),
+        approvalReady: options.wallet?.approvalReady ?? null,
+        localExecutionKeyStored: options.wallet?.localExecutionKeyStored ?? null,
+        relayUrl: options.relayUrl || null,
+        nextAction: recommendedCommands2.setup,
+        localOnly: true,
+        notes: [
+          "Local config is missing, so the canonical operator path should start with setup.",
+          "Doctor is local-only by default and does not require live RPC reads."
+        ]
+      },
+      recommendedCommands: recommendedCommands2
+    };
+  }
+  if (!options.wallet) {
+    const recommendedCommands2 = buildWalletBootstrapRecommendedCommands(
+      options.walletName,
+      options.relayUrl
+    );
+    const onboardingSummary2 = buildOnboardingSummary({
+      stage: "wallet-bootstrap",
+      localOnly: true,
+      configExists: true,
+      walletExists: false,
+      defaultChain: options.config.defaultChain,
+      connectorUrl: options.config.connectorUrl,
+      relayUrl: options.relayUrl || null,
+      nextAction: recommendedCommands2.createWallet,
+      notes: [
+        "Local config exists, but no saved wallet record was found for this name yet.",
+        "Use the remote relay path only when the browser is not colocated with this terminal."
+      ]
+    });
+    return {
+      scope: "wallet-bootstrap",
+      nextAction: recommendedCommands2.createWallet,
+      onboardingSummary: onboardingSummary2,
+      summary: {
+        stage: "wallet-bootstrap",
+        configExists: true,
+        walletExists: false,
+        approvalReady: null,
+        localExecutionKeyStored: null,
+        relayUrl: options.relayUrl || null,
+        nextAction: recommendedCommands2.createWallet,
+        localOnly: true,
+        notes: [
+          "Local config exists, but no saved wallet record was found for this name yet.",
+          "Use the remote relay path only when the browser is not colocated with this terminal."
+        ]
+      },
+      recommendedCommands: recommendedCommands2
+    };
+  }
+  if (!options.wallet.approvalReady) {
+    const recommendedCommands2 = buildWalletRecoveryRecommendedCommands(
+      options.wallet,
+      options.relayUrl
+    );
+    const onboardingSummary2 = buildOnboardingSummary({
+      stage: "wallet-recovery",
+      localOnly: true,
+      configExists: true,
+      walletExists: true,
+      approvalReady: false,
+      localExecutionKeyStored: options.wallet.localExecutionKeyStored,
+      defaultChain: options.config.defaultChain,
+      connectorUrl: options.config.connectorUrl,
+      relayUrl: options.relayUrl || null,
+      nextAction: recommendedCommands2.reapprove,
+      notes: [
+        "A local wallet record exists, but approved session metadata is missing.",
+        "Use the remote reapproval path only when the browser cannot return directly to this terminal."
+      ]
+    });
+    return {
+      scope: "wallet-recovery",
+      nextAction: recommendedCommands2.reapprove,
+      onboardingSummary: onboardingSummary2,
+      summary: {
+        stage: "wallet-recovery",
+        configExists: true,
+        walletExists: true,
+        approvalReady: false,
+        localExecutionKeyStored: options.wallet.localExecutionKeyStored,
+        relayUrl: options.relayUrl || null,
+        nextAction: recommendedCommands2.reapprove,
+        localOnly: true,
+        notes: [
+          "A local wallet record exists, but approved session metadata is missing.",
+          "Use the remote reapproval path only when the browser cannot return directly to this terminal."
+        ]
+      },
+      recommendedCommands: recommendedCommands2
+    };
+  }
+  if (!options.wallet.localExecutionKeyStored) {
+    const attachSigner = buildWalletSignerAttachRecommendedCommand(options.wallet.walletName);
+    const recommendedCommands2 = {
+      ...buildWalletRecoveryRecommendedCommands(options.wallet, options.relayUrl),
+      attachSigner
+    };
+    const onboardingSummary2 = buildOnboardingSummary({
+      stage: "wallet-recovery",
+      localOnly: true,
+      configExists: true,
+      walletExists: true,
+      approvalReady: true,
+      localExecutionKeyStored: false,
+      defaultChain: options.config.defaultChain,
+      connectorUrl: options.config.connectorUrl,
+      relayUrl: options.relayUrl || null,
+      nextAction: attachSigner,
+      notes: [
+        "Approved session metadata exists, but no local execution signer is stored yet.",
+        "Doctor is local-only: it confirms stored signer state, not live chain deployment or gas balance."
+      ]
+    });
+    return {
+      scope: "wallet-recovery",
+      nextAction: attachSigner,
+      onboardingSummary: onboardingSummary2,
+      summary: {
+        stage: "wallet-recovery",
+        configExists: true,
+        walletExists: true,
+        approvalReady: true,
+        localExecutionKeyStored: false,
+        relayUrl: options.relayUrl || null,
+        nextAction: attachSigner,
+        localOnly: true,
+        notes: [
+          "Approved session metadata exists, but no local execution signer is stored yet.",
+          "Doctor is local-only: it confirms stored signer state, not live chain deployment or gas balance."
+        ]
+      },
+      recommendedCommands: recommendedCommands2
+    };
+  }
+  const recommendedCommands = buildWalletReadyRecommendedCommands(options.wallet);
+  const onboardingSummary = buildOnboardingSummary({
+    stage: "wallet-ready",
+    localOnly: true,
+    configExists: true,
+    walletExists: true,
+    approvalReady: true,
+    localExecutionKeyStored: true,
+    defaultChain: options.config.defaultChain,
+    connectorUrl: options.config.connectorUrl,
+    relayUrl: options.relayUrl || null,
+    nextAction: recommendedCommands.next,
+    notes: [
+      "Local config, approval metadata, and a local execution signer are all present.",
+      "Run zk-agent next for the current shortest live path; doctor does not confirm RPC reachability, deployment state, or funding."
+    ]
+  });
+  return {
+    scope: "wallet-ready",
+    nextAction: recommendedCommands.next,
+    onboardingSummary,
+    summary: {
+      stage: "wallet-ready",
+      configExists: true,
+      walletExists: true,
+      approvalReady: true,
+      localExecutionKeyStored: true,
+      relayUrl: options.relayUrl || null,
+      nextAction: recommendedCommands.next,
+      localOnly: true,
+      notes: [
+        "Local config, approval metadata, and a local execution signer are all present.",
+        "Run zk-agent next for the current shortest live path; doctor does not confirm RPC reachability, deployment state, or funding."
+      ]
+    },
+    recommendedCommands
+  };
+}
+function buildDoctorLines(input) {
+  const lines = [
+    ["scope", input.scope],
+    ...onboardingSummaryLines(input.onboardingSummary),
+    ["config", input.config ? "present" : "missing"]
+  ];
+  if (input.config) {
+    lines.push(["default chain", input.config.defaultChain]);
+    lines.push(["connector", input.config.connectorUrl]);
+  }
+  lines.push(["wallet", input.walletName]);
+  lines.push(["wallet record", input.wallet ? "present" : "missing"]);
+  if (input.wallet) {
+    lines.push(["address", input.wallet.walletAddress]);
+    lines.push(["account", input.wallet.accountKind]);
+    lines.push(["chain", `${input.wallet.chain} (${input.wallet.chainId})`]);
+    lines.push(["approval", input.wallet.approvalReady ? "present" : "missing"]);
+    lines.push(["local signer", input.wallet.localExecutionKeyStored ? "stored" : "missing"]);
+    lines.push([
+      "legacy payload mirror",
+      input.wallet.legacySessionKeyStored ? "present" : "missing"
+    ]);
+    if (input.wallet.signerType) {
+      lines.push(["signer type", input.wallet.signerType]);
+    }
+    if (input.wallet.signerAddress) {
+      lines.push(["signer address", input.wallet.signerAddress]);
+    }
+    if (input.wallet.signerSource) {
+      lines.push(["signer source", input.wallet.signerSource]);
+    }
+    if (input.wallet.smartAccountProfileId) {
+      lines.push(["smart-account profile", input.wallet.smartAccountProfileId]);
+    }
+    if (input.wallet.syncedAt) {
+      lines.push(["synced at", input.wallet.syncedAt]);
+    }
+  }
+  lines.push(["next", input.nextAction]);
+  if (input.recommendedCommands.createWallet) {
+    lines.push(["create wallet (local)", input.recommendedCommands.createWallet]);
+  }
+  if (input.recommendedCommands.reapprove) {
+    lines.push(["reapprove", input.recommendedCommands.reapprove]);
+  }
+  if (input.recommendedCommands.attachSigner) {
+    lines.push(["attach signer", input.recommendedCommands.attachSigner]);
+  }
+  if (input.recommendedCommands.workflowPay) {
+    lines.push(["workflow pay", input.recommendedCommands.workflowPay]);
+  }
+  if (input.recommendedCommands.relayInspect) {
+    lines.push(["relay inspect", input.recommendedCommands.relayInspect]);
+  }
+  if (input.recommendedCommands.createWalletRemote) {
+    lines.push(["create wallet (remote)", input.recommendedCommands.createWalletRemote]);
+  }
+  if (input.recommendedCommands.reapproveRemote) {
+    lines.push(["reapprove (remote)", input.recommendedCommands.reapproveRemote]);
+  }
+  for (const note of input.summary.notes) {
+    lines.push(["note", note]);
+  }
+  return lines;
+}
+function createDoctorCommand() {
+  return new Command4("doctor").description("Local-only onboarding and wallet-recovery diagnostic for the default operator path").addHelpText("after", buildDoctorHelpText()).option("--wallet <name>", "Wallet name", "main").option(
+    "--relay-url <url>",
+    "Optional relay URL used only to make remote approval fallback commands concrete"
+  ).action(async (options) => {
+    const walletName = options.wallet?.trim() || "main";
+    const config = await loadProjectConfig();
+    const walletRecord = await loadWalletSession(walletName);
+    const wallet = walletRecord ? summarizeLocalWalletState(walletRecord) : null;
+    const result = buildDoctorResult({
+      walletName,
+      relayUrl: options.relayUrl,
+      wallet,
+      config
+    });
+    const agentProfile = await loadAgentIdentitySummary(walletName);
+    const agentFollowup = buildAgentFollowup(agentProfile, {
+      walletName,
+      walletExists: Boolean(wallet)
+    });
+    printResult(
+      [
+        ...buildDoctorLines({
+          scope: result.scope,
+          walletName,
+          config,
+          wallet,
+          onboardingSummary: result.onboardingSummary,
+          summary: result.summary,
+          recommendedCommands: result.recommendedCommands,
+          nextAction: result.nextAction
+        }),
+        ...agentProfileLines(agentProfile),
+        ...agentFollowupLines(agentFollowup)
+      ],
+      {
+        ok: true,
+        scope: result.scope,
+        walletName,
+        config: config ? {
+          exists: true,
+          defaultChain: config.defaultChain,
+          connectorUrl: config.connectorUrl,
+          provider: config.provider
+        } : {
+          exists: false
+        },
+        wallet,
+        onboardingSummary: result.onboardingSummary,
+        summary: result.summary,
+        agentProfile,
+        agentFollowup,
+        nextAction: result.nextAction,
+        recommendedCommands: result.recommendedCommands
+      }
+    );
+  });
+}
+
+// src/commands/agent.ts
+import { Command as Command5 } from "commander";
 function collectRepeatedString(value, previous) {
   return [...previous, value];
 }
@@ -10842,7 +11595,7 @@ function buildAgentSummaryLines(options) {
   return lines;
 }
 function createAgentCommand() {
-  const agent = new Command4("agent").description(
+  const agent = new Command5("agent").description(
     "Manage local agent identity metadata without assuming a zkSync-native onchain reputation standard"
   );
   agent.addHelpText(
@@ -11035,7 +11788,81 @@ function createAgentCommand() {
 }
 
 // src/commands/defaults.ts
-import { Command as Command5 } from "commander";
+import { Command as Command6 } from "commander";
+function inferPrimaryDiscoveryChain(defaults) {
+  return defaults.defaultSelections.paymaster.validatedDefault?.chain || defaults.defaultSelections.swap.validatedDefault?.chain || defaults.defaultSelections.bridge.validatedWithdraw?.fromChain || defaults.defaultSelections.bridge.validatedDeposit?.toChain || defaults.validated.feeTokenEraVm?.chain || defaults.builtinChains.find((chain) => chain.key === "zksync-sepolia")?.key || defaults.builtinChains[0]?.key || "zksync-sepolia";
+}
+function inferExampleTokenSymbol(defaults) {
+  return defaults.defaultSelections.swap.validatedDefault?.trackedTokenA.symbol || defaults.defaultSelections.paymaster.validatedApprovalBased?.feeTokenSymbol || defaults.validated.feeTokenEraVm?.symbol || defaults.registry.tokens.find((entry) => entry.symbol?.trim())?.symbol || "USDC";
+}
+function inferPaymasterFeeTokenSymbol(defaults) {
+  return defaults.defaultSelections.paymaster.validatedApprovalBased?.feeTokenSymbol || defaults.validated.feeTokenEraVm?.symbol || null;
+}
+function buildDefaultsRecommendedCommands(defaults) {
+  const primaryChain = inferPrimaryDiscoveryChain(defaults);
+  const exampleSymbol = inferExampleTokenSymbol(defaults);
+  const paymasterFeeTokenSymbol = inferPaymasterFeeTokenSymbol(defaults) || exampleSymbol;
+  return {
+    inspectDefaults: buildDefaultsRecommendedCommand(),
+    discoverTokens: buildTokensRecommendedCommand(primaryChain),
+    inspectToken: buildResolveTokenRecommendedCommand(primaryChain, exampleSymbol),
+    discoverPaymasterTokens: buildPaymasterFeeTokensRecommendedCommand(primaryChain),
+    inspectPaymasterToken: buildPaymasterFeeTokenResolveRecommendedCommand(
+      primaryChain,
+      paymasterFeeTokenSymbol
+    )
+  };
+}
+function buildDefaultsSummary(input) {
+  const { defaults, localTokenRegistry, tokenRegistrySources, tokenDirectoryChains } = input;
+  const primaryChain = inferPrimaryDiscoveryChain(defaults);
+  const exampleTokenSymbol = inferExampleTokenSymbol(defaults);
+  const paymasterFeeTokenSymbol = inferPaymasterFeeTokenSymbol(defaults);
+  return {
+    primaryDiscoveryChain: primaryChain,
+    exampleTokenSymbol,
+    paymasterFeeTokenSymbol,
+    localTokenCount: localTokenRegistry.length,
+    tokenDirectoryChainCount: tokenDirectoryChains.length,
+    tokenRegistrySources: tokenRegistrySources.map((source) => ({
+      id: source.id,
+      enabled: source.enabled,
+      exists: source.exists
+    })),
+    resolvedDefaults: {
+      swap: defaults.defaultSelections.swap.validatedDefault ? {
+        entryId: defaults.defaultSelections.swap.validatedDefault.entryId,
+        chain: defaults.defaultSelections.swap.validatedDefault.chain,
+        protocol: defaults.defaultSelections.swap.validatedDefault.protocol,
+        status: defaults.defaultSelections.swap.validatedDefault.status
+      } : null,
+      bridgeDeposit: defaults.defaultSelections.bridge.validatedDeposit ? {
+        entryId: defaults.defaultSelections.bridge.validatedDeposit.entryId,
+        fromChain: defaults.defaultSelections.bridge.validatedDeposit.fromChain,
+        toChain: defaults.defaultSelections.bridge.validatedDeposit.toChain,
+        status: defaults.defaultSelections.bridge.validatedDeposit.status
+      } : null,
+      bridgeWithdraw: defaults.defaultSelections.bridge.validatedWithdraw ? {
+        entryId: defaults.defaultSelections.bridge.validatedWithdraw.entryId,
+        fromChain: defaults.defaultSelections.bridge.validatedWithdraw.fromChain,
+        toChain: defaults.defaultSelections.bridge.validatedWithdraw.toChain,
+        status: defaults.defaultSelections.bridge.validatedWithdraw.status,
+        requiresFinalize: defaults.defaultSelections.bridge.validatedWithdraw.requiresFinalize
+      } : null,
+      paymasterDefault: defaults.defaultSelections.paymaster.validatedDefault ? {
+        entryId: defaults.defaultSelections.paymaster.validatedDefault.entryId,
+        chain: defaults.defaultSelections.paymaster.validatedDefault.chain,
+        mode: defaults.defaultSelections.paymaster.validatedDefault.mode,
+        status: defaults.defaultSelections.paymaster.validatedDefault.status
+      } : null,
+      paymasterByMode: {
+        none: defaults.defaultSelections.paymaster.validatedNone?.entryId || null,
+        sponsored: defaults.defaultSelections.paymaster.validatedSponsored?.entryId || null,
+        approvalBased: defaults.defaultSelections.paymaster.validatedApprovalBased?.entryId || null
+      }
+    }
+  };
+}
 function formatTrackedTokenSummary(token) {
   if (!token.address) return null;
   const label = token.symbol || token.address;
@@ -11509,7 +12336,7 @@ function buildDefaultsLines(input) {
   return lines;
 }
 function createDefaultsCommand() {
-  return new Command5("defaults").description("Show the machine-readable registry of supported, validated, experimental, and manually configured defaults").addHelpText(
+  return new Command6("defaults").description("Show the machine-readable registry of supported, validated, experimental, and manually configured defaults").addHelpText(
     "after",
     [
       "",
@@ -11531,14 +12358,34 @@ function createDefaultsCommand() {
     const localTokenRegistry = listLocalTokenRegistryEntries();
     const tokenRegistrySources = describeDefaultTokenRegistrySources();
     const tokenDirectoryChains = await listTokenDirectoryIndexedChains();
+    const recommendedCommands = buildDefaultsRecommendedCommands(defaults);
+    const summary = buildDefaultsSummary({
+      defaults,
+      localTokenRegistry,
+      tokenRegistrySources,
+      tokenDirectoryChains
+    });
     const lines = buildDefaultsLines({
       defaults,
       localTokenRegistry,
       tokenRegistrySources,
       tokenDirectoryChains
     });
+    lines.push([
+      "next discovery chain",
+      summary.primaryDiscoveryChain
+    ]);
+    lines.push([
+      "example token",
+      summary.exampleTokenSymbol
+    ]);
+    if (summary.paymasterFeeTokenSymbol) {
+      lines.push(["paymaster fee token symbol", summary.paymasterFeeTokenSymbol]);
+    }
     printResult(lines, {
       ok: true,
+      summary,
+      recommendedCommands,
       defaults,
       localTokenRegistry,
       tokenRegistrySources,
@@ -11548,7 +12395,7 @@ function createDefaultsCommand() {
 }
 
 // src/commands/resolve-token.ts
-import { Command as Command6 } from "commander";
+import { Command as Command7 } from "commander";
 function resolveResolveTokenCommandDeps(deps) {
   return {
     loadWallet: deps?.loadWallet ?? (async (walletName) => {
@@ -11584,9 +12431,29 @@ async function resolveActiveChain(options, deps) {
     }
   );
 }
+function buildResolveTokenDiscoverySummary(result) {
+  return {
+    chain: result.chainKey,
+    chainId: result.chainId,
+    queryType: result.queryType,
+    query: result.queryType === "symbol" ? result.symbol || null : result.address || null,
+    roleFilter: result.role || null,
+    sourceFilter: result.source || null,
+    matchCount: result.matchCount,
+    ambiguous: result.ambiguous,
+    primarySymbol: result.primaryMatch?.symbol || null,
+    primaryAddress: result.primaryMatch?.address || null,
+    primaryDecimals: result.primaryMatch?.decimals ?? null,
+    primarySource: result.primaryMatch?.source || (result.primaryMatch ? "unknown" : null),
+    sourceCounts: summarizeDiscoveryEntrySources(result.matches),
+    roleMatchCounts: summarizeDiscoveryRoleMatches(result.matches),
+    currentDefaultEntryCount: countCurrentValidatedDefaultEntries(result.matches),
+    tokenRegistrySources: summarizeTokenRegistrySources(result.tokenRegistrySources)
+  };
+}
 function createResolveTokenCommand(deps) {
   const resolvedDeps = resolveResolveTokenCommandDeps(deps);
-  return new Command6("resolve-token").description("Resolve a token symbol or address against the configured local-first token registry").addHelpText(
+  return new Command7("resolve-token").description("Resolve a token symbol or address against the configured local-first token registry").addHelpText(
     "after",
     [
       "",
@@ -11688,6 +12555,7 @@ function createResolveTokenCommand(deps) {
     lines.push(...workflowFollowupLines(recommendedCommands));
     printResult(lines, {
       ok: true,
+      discoverySummary: buildResolveTokenDiscoverySummary(result),
       recommendedCommands,
       ...result
     });
@@ -11719,7 +12587,7 @@ function normalizeSource(value) {
 }
 
 // src/commands/tokens.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 var provider2 = new ZkSyncWalletProvider();
 function resolveTokensCommandDeps(deps) {
   return {
@@ -11807,9 +12675,49 @@ function ownedTokenSummaryLines2(summary) {
   }
   return lines;
 }
+function buildOwnedTokensDiscoverySummary(result) {
+  return {
+    mode: "owned-registry-erc20",
+    walletName: result.walletName,
+    chainScope: result.chainFilter.chainKey,
+    chainCount: 1,
+    entryCount: result.entryCount,
+    symbolFilter: result.symbol || null,
+    roleFilter: result.role || null,
+    sourceFilter: result.source || null,
+    primarySymbol: firstDiscoverySymbol(result.entries),
+    primarySource: firstDiscoverySource(result.entries),
+    sourceCounts: result.summary.sourceCounts,
+    roleMatchCounts: result.summary.registryRoleCounts,
+    currentDefaultEntryCount: countCurrentValidatedDefaultEntries(result.entries),
+    probeFailureCount: result.probeFailureCount,
+    bridgeMappingCounts: result.summary.bridgeMappingCounts,
+    tokenRegistrySources: summarizeTokenRegistrySources(result.tokenRegistrySources)
+  };
+}
+function buildTokenDiscoverySummary(result) {
+  return {
+    mode: "discoverable",
+    walletName: null,
+    chainScope: result.chainFilter?.chainKey || "all-built-in-chains",
+    chainCount: result.chainFilter ? 1 : listUniqueDiscoveryChains(result.entries).length,
+    entryCount: result.entryCount,
+    symbolFilter: result.symbol || null,
+    roleFilter: result.role || null,
+    sourceFilter: result.source || null,
+    primarySymbol: firstDiscoverySymbol(result.entries),
+    primarySource: firstDiscoverySource(result.entries),
+    sourceCounts: summarizeDiscoveryEntrySources(result.entries),
+    roleMatchCounts: summarizeDiscoveryRoleMatches(result.entries),
+    currentDefaultEntryCount: countCurrentValidatedDefaultEntries(result.entries),
+    probeFailureCount: null,
+    bridgeMappingCounts: null,
+    tokenRegistrySources: summarizeTokenRegistrySources(result.tokenRegistrySources)
+  };
+}
 function createTokensCommand(deps) {
   const resolvedDeps = resolveTokensCommandDeps(deps);
-  return new Command7("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 Command8("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",
     [
       "",
@@ -11940,6 +12848,7 @@ function createTokensCommand(deps) {
       lines2.push(...workflowFollowupLines(recommendedCommands2));
       printResult(lines2, {
         ok: true,
+        discoverySummary: buildOwnedTokensDiscoverySummary(result2),
         recommendedCommands: recommendedCommands2,
         ...result2
       });
@@ -11995,6 +12904,7 @@ function createTokensCommand(deps) {
     lines.push(...workflowFollowupLines(recommendedCommands));
     printResult(lines, {
       ok: true,
+      discoverySummary: buildTokenDiscoverySummary(result),
       recommendedCommands,
       ...result
     });
@@ -12012,7 +12922,7 @@ function normalizeRole2(value) {
 }
 
 // src/commands/relay.ts
-import { Command as Command8 } from "commander";
+import { Command as Command9 } from "commander";
 
 // src/lib/relay.ts
 import { createServer } from "node:http";
@@ -12520,10 +13430,52 @@ async function startRelayServer(options) {
 }
 
 // src/commands/relay.ts
-function buildRelayServeRecommendedCommands(relayUrl) {
+function buildRelayServeRecommendedCommands(options) {
+  const commands = {
+    inspectRelay: `zk-agent relay inspect --relay-url ${options.relayUrl}`,
+    createWallet: `zk-agent wallet create --relay-url ${options.relayUrl} --wait-relay --prompt-code`,
+    reapproveWallet: `zk-agent wallet reapprove --name main --relay-url ${options.relayUrl} --wait-relay --prompt-code`
+  };
+  if (options.publicOriginLooksLocal) {
+    return {
+      ...commands,
+      restartWithPublicOrigin: "zk-agent relay serve --public-origin https://relay.example.com"
+    };
+  }
+  return commands;
+}
+function buildRelayInspectRecommendedCommands(options) {
+  const commands = {};
+  if (options.compatible) {
+    commands.createWallet = `zk-agent wallet create --relay-url ${options.publicOrigin} --wait-relay --prompt-code`;
+    commands.reapproveWallet = `zk-agent wallet reapprove --name main --relay-url ${options.publicOrigin} --wait-relay --prompt-code`;
+  }
+  if (options.publicOriginLooksLocal) {
+    commands.restartWithPublicOrigin = "zk-agent relay serve --public-origin https://relay.example.com";
+  }
+  return commands;
+}
+function buildRelayHostedReadinessSummary(options) {
+  let status;
+  if (!options.compatible) {
+    status = "incompatible";
+  } else if (options.publicOriginLooksLocal && options.connectorUiAvailable !== true) {
+    status = "needs-public-origin-and-ui";
+  } else if (options.publicOriginLooksLocal) {
+    status = "needs-public-origin";
+  } else if (options.connectorUiAvailable !== true) {
+    status = "needs-connector-ui";
+  } else {
+    status = "ready";
+  }
   return {
-    createWallet: `zk-agent wallet create --relay-url ${relayUrl} --wait-relay --prompt-code`,
-    reapproveWallet: `zk-agent wallet reapprove --name main --relay-url ${relayUrl} --wait-relay --prompt-code`
+    status,
+    compatible: options.compatible,
+    hostedApprovalReady: options.hostedShareRedirectReady,
+    publicOriginConfigured: options.publicOriginSource === "configured",
+    publicOriginLooksLocal: options.publicOriginLooksLocal,
+    connectorUiAvailable: options.connectorUiAvailable,
+    singleHostFileState: options.deploymentSummary.singleHostFileState
   };
 }
 function buildAdvertisedRelayBases(publicOrigin) {
@@ -12532,6 +13484,24 @@ function buildAdvertisedRelayBases(publicOrigin) {
     statusApiBaseUrl: `${publicOrigin}/api/requests`
   };
 }
+function buildRelayApprovalEndpointSummary(options) {
+  let status;
+  if (options.publicOriginLooksLocal) {
+    status = "local-public-origin";
+  } else if (options.relayUrlMatchesPublicOrigin === false) {
+    status = "hosted-public-origin-via-proxy";
+  } else {
+    status = "hosted-public-origin";
+  }
+  return {
+    status,
+    publicOriginConfigured: options.publicOriginSource === "configured",
+    publicOriginLooksLocal: options.publicOriginLooksLocal,
+    relayUrlMatchesPublicOrigin: options.relayUrlMatchesPublicOrigin,
+    shareLinkBaseUrl: options.shareLinkBaseUrl,
+    statusApiBaseUrl: options.statusApiBaseUrl
+  };
+}
 function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -12672,6 +13642,20 @@ function relayOriginRelationshipNotes(options) {
   }
   return notes;
 }
+function buildRelayDeploymentSummary(options) {
+  return {
+    origin: options.origin,
+    publicOrigin: options.publicOrigin,
+    publicOriginSource: options.publicOriginSource,
+    shareLinkBaseUrl: options.shareLinkBaseUrl,
+    statusApiBaseUrl: options.statusApiBaseUrl,
+    publicOriginConfigured: options.publicOriginSource === "configured",
+    publicOriginLooksLocal: options.publicOriginLooksLocal,
+    connectorUiAvailable: options.connectorUiAvailable,
+    hostedShareRedirectReady: options.hostedShareRedirectReady,
+    singleHostFileState: options.stateBackend === "local-filesystem" && options.deploymentScope === "single-host" && options.sameHostRestartPersists === true
+  };
+}
 function buildRelayInspectPayload(relayUrl, rawHealth) {
   const health = asRelayHealthResponse(rawHealth);
   const fallbackPublicOrigin = isRecord3(rawHealth) && typeof rawHealth.public_origin === "string" ? rawHealth.public_origin : relayUrl;
@@ -12690,6 +13674,34 @@ function buildRelayInspectPayload(relayUrl, rawHealth) {
   const publicOriginLooksLocal = relayPublicOriginLooksLocal(publicOrigin);
   const hostedShareRedirectReady = compatible && connectorUiAvailable === true && !publicOriginLooksLocal;
   const { shareLinkBaseUrl, statusApiBaseUrl } = buildAdvertisedRelayBases(publicOrigin);
+  const deploymentSummary = buildRelayDeploymentSummary({
+    origin: health?.origin || null,
+    publicOrigin,
+    publicOriginSource,
+    shareLinkBaseUrl,
+    statusApiBaseUrl,
+    publicOriginLooksLocal,
+    connectorUiAvailable,
+    hostedShareRedirectReady,
+    stateBackend,
+    deploymentScope,
+    sameHostRestartPersists
+  });
+  const approvalEndpointSummary = buildRelayApprovalEndpointSummary({
+    publicOriginSource,
+    publicOriginLooksLocal,
+    relayUrlMatchesPublicOrigin,
+    shareLinkBaseUrl,
+    statusApiBaseUrl
+  });
+  const hostedReadinessSummary = buildRelayHostedReadinessSummary({
+    compatible,
+    publicOriginSource,
+    publicOriginLooksLocal,
+    connectorUiAvailable,
+    hostedShareRedirectReady,
+    deploymentSummary
+  });
   const notes = [
     ...relayHostedReadinessNotes({
       compatible,
@@ -12729,15 +13741,22 @@ function buildRelayInspectPayload(relayUrl, rawHealth) {
     relayUrlMatchesOrigin,
     relayUrlMatchesPublicOrigin,
     publicOriginLooksLocal,
+    approvalEndpointSummary,
     connectorUiAvailable,
     hostedShareRedirectReady,
+    hostedReadinessSummary,
+    deploymentSummary,
     capabilities: health?.capabilities || [],
-    recommendedCommands: compatible ? buildRelayServeRecommendedCommands(publicOrigin) : {},
+    recommendedCommands: buildRelayInspectRecommendedCommands({
+      publicOrigin,
+      compatible,
+      publicOriginLooksLocal
+    }),
     notes
   };
 }
 function createRelayCommand() {
-  const relay = new Command8("relay").description("Run the local connector relay prototype server");
+  const relay = new Command9("relay").description("Run the local connector relay prototype server");
   relay.addHelpText(
     "after",
     [
@@ -12769,13 +13788,44 @@ function createRelayCommand() {
       port: parsedPort,
       publicOrigin: options.publicOrigin?.trim()
     });
-    const publicOrigin = options.publicOrigin?.trim() || server.origin;
-    const publicOriginSource = options.publicOrigin?.trim() ? "configured" : "bind-origin-default";
-    const publicOriginLooksLocal = relayPublicOriginLooksLocal(publicOrigin);
-    const connectorUiAvailable = server.connectorUiAvailable;
-    const hostedShareRedirectReady = connectorUiAvailable && !publicOriginLooksLocal;
-    const { shareLinkBaseUrl, statusApiBaseUrl } = buildAdvertisedRelayBases(publicOrigin);
-    const recommendedCommands = buildRelayServeRecommendedCommands(publicOrigin);
+    const publicOrigin = options.publicOrigin?.trim() || server.origin;
+    const publicOriginSource = options.publicOrigin?.trim() ? "configured" : "bind-origin-default";
+    const publicOriginLooksLocal = relayPublicOriginLooksLocal(publicOrigin);
+    const connectorUiAvailable = server.connectorUiAvailable;
+    const hostedShareRedirectReady = connectorUiAvailable && !publicOriginLooksLocal;
+    const { shareLinkBaseUrl, statusApiBaseUrl } = buildAdvertisedRelayBases(publicOrigin);
+    const recommendedCommands = buildRelayServeRecommendedCommands({
+      relayUrl: publicOrigin,
+      publicOriginLooksLocal
+    });
+    const deploymentSummary = buildRelayDeploymentSummary({
+      origin: server.origin,
+      publicOrigin,
+      publicOriginSource,
+      shareLinkBaseUrl,
+      statusApiBaseUrl,
+      publicOriginLooksLocal,
+      connectorUiAvailable,
+      hostedShareRedirectReady,
+      stateBackend: "local-filesystem",
+      deploymentScope: "single-host",
+      sameHostRestartPersists: true
+    });
+    const hostedReadinessSummary = buildRelayHostedReadinessSummary({
+      compatible: true,
+      publicOriginSource,
+      publicOriginLooksLocal,
+      connectorUiAvailable,
+      hostedShareRedirectReady,
+      deploymentSummary
+    });
+    const approvalEndpointSummary = buildRelayApprovalEndpointSummary({
+      publicOriginSource,
+      publicOriginLooksLocal,
+      relayUrlMatchesPublicOrigin: null,
+      shareLinkBaseUrl,
+      statusApiBaseUrl
+    });
     const notes = relayHostedReadinessNotes({
       compatible: true,
       publicOrigin,
@@ -12794,6 +13844,9 @@ function createRelayCommand() {
       shareLinkBaseUrl,
       statusApiBaseUrl,
       publicOriginLooksLocal,
+      approvalEndpointSummary,
+      hostedReadinessSummary,
+      deploymentSummary,
       port: server.port,
       healthUrl: `${server.origin}/health`,
       publicHealthUrl: `${publicOrigin}/health`,
@@ -12828,13 +13881,19 @@ function createRelayCommand() {
       );
       humanLine("share-link base", shareLinkBaseUrl);
       humanLine("status api base", statusApiBaseUrl);
+      humanLine("approval endpoint", approvalEndpointSummary.status);
       humanLine("health", `${server.origin}/health`);
+      humanLine("hosted readiness", hostedReadinessSummary.status);
       humanLine("hosted ready", hostedShareRedirectReady ? "yes" : "no");
       if (connectorUiAvailable !== null) {
         humanLine("connector ui", connectorUiAvailable ? "available" : "missing");
       }
+      humanLine("inspect relay", recommendedCommands.inspectRelay);
       humanLine("create wallet", recommendedCommands.createWallet);
       humanLine("reapprove wallet", recommendedCommands.reapproveWallet);
+      if (recommendedCommands.restartWithPublicOrigin) {
+        humanLine("restart with public origin", recommendedCommands.restartWithPublicOrigin);
+      }
       for (const note of notes) {
         humanLine("note", note);
       }
@@ -12896,6 +13955,8 @@ function createRelayCommand() {
     }
     humanLine("share-link base", payload.shareLinkBaseUrl);
     humanLine("status api base", payload.statusApiBaseUrl);
+    humanLine("approval endpoint", payload.approvalEndpointSummary.status);
+    humanLine("hosted readiness", payload.hostedReadinessSummary.status);
     if (payload.relayUrlMatchesOrigin !== null) {
       humanLine("relay url matches origin", payload.relayUrlMatchesOrigin ? "yes" : "no");
     }
@@ -12921,6 +13982,12 @@ function createRelayCommand() {
         humanLine("reapprove wallet", payload.recommendedCommands.reapproveWallet);
       }
     }
+    if (payload.recommendedCommands.restartWithPublicOrigin) {
+      humanLine(
+        "restart with public origin",
+        payload.recommendedCommands.restartWithPublicOrigin
+      );
+    }
     for (const note of payload.notes) {
       humanLine("note", note);
     }
@@ -12931,7 +13998,7 @@ function createRelayCommand() {
 // src/commands/wallet.ts
 import { createServer as createServer2 } from "node:http";
 import { createInterface } from "node:readline/promises";
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // ../account-profiles/src/profiles.ts
 import fs8 from "node:fs";
@@ -13536,6 +14603,39 @@ function relayOutputAliases(relay) {
     relayStatusApiBaseUrl: statusApiBaseUrl
   };
 }
+function determineRelayRecoveryMode(options) {
+  if (options.recommendedCommands.reissueRemoteApproval && options.nextAction === options.recommendedCommands.reissueRemoteApproval) {
+    return "reissue-remote-approval";
+  }
+  if (options.recommendedCommands.relayInspect && options.nextAction === options.recommendedCommands.relayInspect) {
+    return "inspect-relay";
+  }
+  if (options.recommendedCommands.approve && options.nextAction === options.recommendedCommands.approve) {
+    return "approve";
+  }
+  return "status-poll";
+}
+function buildRelayRecoverySummary(options) {
+  const aliases = relayOutputAliases(options.relay);
+  return {
+    requestId: options.requestId,
+    walletName: options.walletName || null,
+    relayUrl: options.relayUrl,
+    relayStatus: options.relayStatus ?? options.relay?.status ?? null,
+    approvalReady: typeof options.approvalReady === "boolean" ? options.approvalReady : options.relay && "approval_ready" in options.relay ? options.relay.approval_ready : null,
+    nextAction: options.nextAction,
+    shareLinkBaseUrl: aliases.relayShareLinkBaseUrl || null,
+    statusApiBaseUrl: aliases.relayStatusApiBaseUrl || null,
+    recoveryMode: determineRelayRecoveryMode({
+      nextAction: options.nextAction,
+      recommendedCommands: options.recommendedCommands
+    }),
+    includesStatusPoll: Boolean(options.recommendedCommands.status),
+    includesApprove: Boolean(options.recommendedCommands.approve),
+    includesRelayInspect: Boolean(options.recommendedCommands.relayInspect),
+    includesRemoteReissue: Boolean(options.recommendedCommands.reissueRemoteApproval)
+  };
+}
 function sanitizeWalletRequestRecord(request) {
   const { sessionSecretKey: _sessionSecretKey, ...rest } = request;
   return rest;
@@ -14833,7 +15933,9 @@ async function buildRelayStatusFollowUp(options) {
       walletName: options.relay.request?.walletName,
       relayUrl: options.relayUrl,
       paymasterMode: options.relay.request?.requestedPaymasterMode,
-      accountKind: options.relay.request?.requestedAccountKind
+      accountKind: options.relay.request?.requestedAccountKind,
+      sessionPolicies: options.relay.request?.policies,
+      requestCreatedAt: options.relay.request?.createdAt
     });
   }
   if (options.relay.approval_ready) {
@@ -14878,11 +15980,18 @@ async function buildRelayExpiredRecoveryCommands(options) {
     };
   }
   const existingWallet = await loadWalletSession(walletName);
-  const reissueRemoteApproval = existingWallet ? buildWalletReapproveRemoteRecommendedCommand(walletName, options.relayUrl) : buildWalletCreateRemoteRecommendedCommand(
+  const reissueRemoteApproval = existingWallet ? buildWalletReapproveRemoteRecommendedCommand(walletName, options.relayUrl, {
+    sessionPolicies: options.sessionPolicies,
+    requestCreatedAt: options.requestCreatedAt
+  }) : buildWalletCreateRemoteRecommendedCommand(
     options.relayUrl,
     options.paymasterMode,
     walletName,
-    options.accountKind
+    options.accountKind,
+    {
+      sessionPolicies: options.sessionPolicies,
+      requestCreatedAt: options.requestCreatedAt
+    }
   );
   return {
     nextAction: reissueRemoteApproval,
@@ -14890,7 +15999,7 @@ async function buildRelayExpiredRecoveryCommands(options) {
       relayInspect,
       reissueRemoteApproval
     },
-    note: "Relay approval expired. Reissue the remote request. If the original request used scoped session flags, add those same policy flags again."
+    note: "Relay approval expired. Reissue the remote request. The recovery command preserves any CLI-expressible session-policy flags from the expired request."
   };
 }
 function buildRelayApprovalTimeoutError(options) {
@@ -14913,6 +16022,18 @@ function buildRelayApprovalTimeoutError(options) {
       retryable: true,
       statusCommand,
       approveCommand,
+      relayRecoverySummary: buildRelayRecoverySummary({
+        requestId: options.requestId,
+        walletName: options.walletName,
+        relayUrl: options.relayUrl,
+        relayStatus: null,
+        approvalReady: null,
+        nextAction: statusCommand,
+        recommendedCommands: {
+          status: statusCommand,
+          approve: approveCommand
+        }
+      }),
       suggestedAction: "Check the current relay status, then finalize the wallet approval once approval_ready=true."
     }
   );
@@ -14922,7 +16043,9 @@ async function buildRelayApprovalExpiredError(options) {
     walletName: options.walletName,
     relayUrl: options.relayUrl,
     paymasterMode: options.paymasterMode,
-    accountKind: options.accountKind
+    accountKind: options.accountKind,
+    sessionPolicies: options.sessionPolicies,
+    requestCreatedAt: options.requestCreatedAt
   });
   return new AgentError(
     "RELAY_APPROVAL_EXPIRED",
@@ -14934,6 +16057,15 @@ async function buildRelayApprovalExpiredError(options) {
       note: recovery.note,
       relayInspectCommand: recovery.recommendedCommands.relayInspect,
       reissueRemoteApprovalCommand: recovery.recommendedCommands.reissueRemoteApproval,
+      relayRecoverySummary: buildRelayRecoverySummary({
+        requestId: options.requestId,
+        walletName: options.walletName,
+        relayUrl: options.relayUrl,
+        relayStatus: "expired",
+        approvalReady: false,
+        nextAction: recovery.nextAction,
+        recommendedCommands: recovery.recommendedCommands
+      }),
       suggestedAction: "Inspect the hosted relay, then reissue the remote approval request."
     }
   );
@@ -14958,6 +16090,17 @@ function buildRelayApprovalNotReadyError(options) {
       retryable: true,
       statusCommand,
       approveCommand,
+      relayRecoverySummary: buildRelayRecoverySummary({
+        requestId: options.requestId,
+        relayUrl: options.relayUrl,
+        relayStatus: options.status,
+        approvalReady: options.approvalReady,
+        nextAction: statusCommand,
+        recommendedCommands: {
+          status: statusCommand,
+          approve: approveCommand
+        }
+      }),
       suggestedAction: "Check the current relay status, then retry approval once approval_ready=true."
     }
   );
@@ -15137,6 +16280,7 @@ async function finalizePublishedRelayWalletRequest(options) {
     if (error instanceof Error && error.message.startsWith("Timed out waiting for relay approval after ")) {
       throw buildRelayApprovalTimeoutError({
         requestId: options.walletRequest.requestId,
+        walletName: options.walletRequest.walletName,
         relayUrl: options.relayUrl,
         timeoutMs: options.timeoutMs,
         intervalMs: options.intervalMs
@@ -15148,7 +16292,9 @@ async function finalizePublishedRelayWalletRequest(options) {
         walletName: options.walletRequest.walletName,
         relayUrl: options.relayUrl,
         paymasterMode: options.walletRequest.requestedPaymasterMode,
-        accountKind: options.walletRequest.requestedAccountKind
+        accountKind: options.walletRequest.requestedAccountKind,
+        sessionPolicies: options.walletRequest.policies,
+        requestCreatedAt: options.walletRequest.createdAt
       });
     }
     throw error;
@@ -15519,32 +16665,32 @@ async function printBuiltinSmartAccountProfiles() {
 }
 function createWalletCommand(deps) {
   const resolvedDeps = resolveWalletCommandDeps(deps);
-  const wallet = new Command9("wallet").description(
+  const wallet = new Command10("wallet").description(
     "Create, inspect, and recover local-first wallet sessions"
   );
-  const request = new Command9("request").description("Inspect and finalize pending wallet requests");
-  const signer = new Command9("signer").description(
+  const request = new Command10("request").description("Inspect and finalize pending wallet requests");
+  const signer = new Command10("signer").description(
     "Inspect and manage the stored local execution signer for a wallet"
   );
-  const smartAccount = new Command9("smart-account").description(
+  const smartAccount = new Command10("smart-account").description(
     "Predict and deploy zkSync smart-account contracts from a supplied artifact or built-in profile"
   );
-  const sedLite = new Command9("sed-lite").description(
+  const sedLite = new Command10("sed-lite").description(
     "Inspect and manage the SED modular smart-account profile"
   );
-  const nativeCapHook = new Command9("native-cap-hook").description(
+  const nativeCapHook = new Command10("native-cap-hook").description(
     "Inspect and manage the first SED Lite validation-hook policy: native per-transaction spend caps"
   );
-  const targetAllowlistHook = new Command9("target-allowlist-hook").description(
+  const targetAllowlistHook = new Command10("target-allowlist-hook").description(
     "Inspect and manage the SED Lite validation-hook policy that restricts transactions to an allowlisted target set"
   );
-  const selectorAllowlistHook = new Command9("selector-allowlist-hook").description(
+  const selectorAllowlistHook = new Command10("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 Command9("daily-spend-limit").description(
+  const dailySpendLimit = new Command10("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 Command9("paymaster").description(
+  const paymaster = new Command10("paymaster").description(
     "Manage saved paymaster defaults for stored wallets"
   );
   wallet.addHelpText(
@@ -15552,6 +16698,9 @@ function createWalletCommand(deps) {
     [
       "",
       "Local-first wallet path:",
+      "  Use this layer when the blocker is specifically about wallet approval or signer state.",
+      "  Otherwise start with `zk-agent next` or `zk-agent doctor`.",
+      "",
       "  First bootstrap:",
       "    zk-agent wallet create --await-local",
       "    zk-agent next",
@@ -15572,7 +16721,8 @@ function createWalletCommand(deps) {
       "    zk-agent relay inspect --relay-url <url>",
       "    zk-agent wallet create --relay-url <url> --wait-relay --prompt-code",
       "    zk-agent wallet reapprove --name main --relay-url <url> --wait-relay --prompt-code",
-      "    zk-agent next"
+      "    zk-agent next",
+      "    Use this only when the browser is not colocated with the terminal."
     ].join("\n")
   );
   request.addHelpText(
@@ -15643,7 +16793,28 @@ function createWalletCommand(deps) {
   ).option("--disallow-transfers", "Disable transfer capability for the approved session").option(
     "--disallow-contract-calls",
     "Disable contract-call capability for the approved session"
-  ).option("--connector-url <url>", "Connector UI base URL override").option("--relay-url <url>", "Relay server base URL for immediate remote approval publishing").option("--account-kind <kind>", "Requested account kind", "smart-account").option("--paymaster-mode <mode>", "Requested paymaster mode", "none").option("--await-local", "Immediately wait for a local connector approval callback").option("--wait-relay", "Wait for relay approval readiness and finalize from the same command (requires --relay-url and either --code or --prompt-code)").option("--code <code>", "6-digit relay approval code used together with --wait-relay").option("--prompt-code", "Read the 6-digit relay approval code from stdin after the relay approval is ready").option("--host <host>", "Loopback host to bind when using --await-local", "127.0.0.1").option("--port <port>", "Loopback port to bind when using --await-local (0 = choose a free port)", "0").option("--timeout-seconds <seconds>", "How long to wait when using --await-local or --wait-relay", "600").option("--interval-ms <milliseconds>", "How often to poll relay status while using --wait-relay", "2000").action(
+  ).option("--connector-url <url>", "Connector UI base URL override").option("--relay-url <url>", "Relay server base URL for immediate remote approval publishing").option("--account-kind <kind>", "Requested account kind", "smart-account").option("--paymaster-mode <mode>", "Requested paymaster mode", "none").option("--await-local", "Immediately wait for a local connector approval callback").option("--wait-relay", "Wait for relay approval readiness and finalize from the same command (requires --relay-url and either --code or --prompt-code)").option("--code <code>", "6-digit relay approval code used together with --wait-relay").option("--prompt-code", "Read the 6-digit relay approval code from stdin after the relay approval is ready").option("--host <host>", "Loopback host to bind when using --await-local", "127.0.0.1").option("--port <port>", "Loopback port to bind when using --await-local (0 = choose a free port)", "0").option("--timeout-seconds <seconds>", "How long to wait when using --await-local or --wait-relay", "600").option("--interval-ms <milliseconds>", "How often to poll relay status while using --wait-relay", "2000").addHelpText(
+    "after",
+    [
+      "",
+      "Default wallet-create path:",
+      "  Keep `--await-local` as the local-first baseline when the browser and terminal are colocated.",
+      "",
+      "  Fresh bootstrap:",
+      "    zk-agent next",
+      "    zk-agent wallet create --await-local",
+      "    zk-agent next",
+      "",
+      "  Remote-browser fallback:",
+      "    zk-agent relay inspect --relay-url <url>",
+      "    zk-agent wallet create --relay-url <url> --wait-relay --prompt-code",
+      "    zk-agent next",
+      "",
+      "Environment note:",
+      "  No custom .env is required to create the wallet request itself.",
+      "  Add RPC env vars later, before live reads or broadcasts."
+    ].join("\n")
+  ).action(
     async (options) => {
       const config = await loadProjectConfig();
       const chain = options.chain || config?.defaultChain || "zksync-era";
@@ -15737,6 +16908,20 @@ function createWalletCommand(deps) {
         options.relayUrl,
         request2.requestedPaymasterMode
       );
+      const nextAction = buildPendingRequestNextAction(recommendedCommands);
+      const relayRecoverySummary = relay && recommendedCommands.relayStatus && recommendedCommands.relayApprove ? buildRelayRecoverySummary({
+        requestId: request2.requestId,
+        walletName: request2.walletName,
+        relayUrl: options.relayUrl,
+        relayStatus: relay.status,
+        approvalReady: null,
+        nextAction,
+        recommendedCommands: {
+          status: recommendedCommands.relayStatus,
+          approve: recommendedCommands.relayApprove
+        },
+        relay
+      }) : void 0;
       printResult(
         [
           ["wallet", request2.walletName],
@@ -15779,6 +16964,7 @@ function createWalletCommand(deps) {
           approvalUrl: request2.approvalUrl,
           relay,
           ...relayOutputAliases(relay),
+          relayRecoverySummary,
           expiresAt: request2.expiresAt,
           chain: request2.chain,
           chainId: request2.chainId,
@@ -15786,7 +16972,7 @@ function createWalletCommand(deps) {
           paymasterMode: request2.requestedPaymasterMode,
           capabilities: request2.requestedCapabilities,
           sessionScope: request2.requestedSessionScope,
-          nextAction: buildPendingRequestNextAction(recommendedCommands),
+          nextAction,
           recommendedCommands
         }
       );
@@ -15811,7 +16997,27 @@ function createWalletCommand(deps) {
   ).option("--disallow-transfers", "Disable transfer capability for the approved session").option(
     "--disallow-contract-calls",
     "Disable contract-call capability for the approved session"
-  ).option("--connector-url <url>", "Connector UI base URL override").option("--relay-url <url>", "Relay server base URL for immediate remote approval publishing").option("--await-local", "Immediately wait for a local connector approval callback").option("--wait-relay", "Wait for relay approval readiness and finalize from the same command (requires --relay-url and either --code or --prompt-code)").option("--code <code>", "6-digit relay approval code used together with --wait-relay").option("--prompt-code", "Read the 6-digit relay approval code from stdin after the relay approval is ready").option("--host <host>", "Loopback host to bind when using --await-local", "127.0.0.1").option("--port <port>", "Loopback port to bind when using --await-local (0 = choose a free port)", "0").option("--timeout-seconds <seconds>", "How long to wait when using --await-local or --wait-relay", "600").option("--interval-ms <milliseconds>", "How often to poll relay status while using --wait-relay", "2000").action(
+  ).option("--connector-url <url>", "Connector UI base URL override").option("--relay-url <url>", "Relay server base URL for immediate remote approval publishing").option("--await-local", "Immediately wait for a local connector approval callback").option("--wait-relay", "Wait for relay approval readiness and finalize from the same command (requires --relay-url and either --code or --prompt-code)").option("--code <code>", "6-digit relay approval code used together with --wait-relay").option("--prompt-code", "Read the 6-digit relay approval code from stdin after the relay approval is ready").option("--host <host>", "Loopback host to bind when using --await-local", "127.0.0.1").option("--port <port>", "Loopback port to bind when using --await-local (0 = choose a free port)", "0").option("--timeout-seconds <seconds>", "How long to wait when using --await-local or --wait-relay", "600").option("--interval-ms <milliseconds>", "How often to poll relay status while using --wait-relay", "2000").addHelpText(
+    "after",
+    [
+      "",
+      "Default wallet-reapprove path:",
+      "  Use this when the wallet already exists locally but its approval/session must be refreshed.",
+      "",
+      "  Colocated browser + terminal:",
+      "    zk-agent wallet reapprove --name main --await-local",
+      "    zk-agent next",
+      "",
+      "  Remote-browser fallback:",
+      "    zk-agent relay inspect --relay-url <url>",
+      "    zk-agent wallet reapprove --name main --relay-url <url> --wait-relay --prompt-code",
+      "    zk-agent next",
+      "",
+      "Environment note:",
+      "  No custom .env is required to create the reapproval request itself.",
+      "  Add RPC env vars later, before live reads or broadcasts."
+    ].join("\n")
+  ).action(
     async (options) => {
       const walletRecord = await requireWalletRecord(options.name);
       const request2 = await createWalletReapprovalRequest({
@@ -15902,6 +17108,20 @@ function createWalletCommand(deps) {
         options.relayUrl,
         request2.requestedPaymasterMode
       );
+      const nextAction = buildPendingRequestNextAction(recommendedCommands);
+      const relayRecoverySummary = relay && recommendedCommands.relayStatus && recommendedCommands.relayApprove ? buildRelayRecoverySummary({
+        requestId: request2.requestId,
+        walletName: request2.walletName,
+        relayUrl: options.relayUrl,
+        relayStatus: relay.status,
+        approvalReady: null,
+        nextAction,
+        recommendedCommands: {
+          status: recommendedCommands.relayStatus,
+          approve: recommendedCommands.relayApprove
+        },
+        relay
+      }) : void 0;
       printResult(
         [
           ["wallet", request2.walletName],
@@ -15944,7 +17164,8 @@ function createWalletCommand(deps) {
           request: sanitizeWalletRequestRecord(request2),
           relay,
           ...relayOutputAliases(relay),
-          nextAction: buildPendingRequestNextAction(recommendedCommands),
+          relayRecoverySummary,
+          nextAction,
           recommendedCommands
         }
       );
@@ -16079,21 +17300,61 @@ function createWalletCommand(deps) {
     const walletRecord = await loadWalletSession(options.name);
     if (!walletRecord) throw new Error(`Wallet not found: ${options.name}`);
     const { inspection, summary } = await loadWalletStatusSummary(walletRecord, resolvedDeps);
-    printResult(walletStatusLines(inspection, summary), { ok: true, inspection, summary });
+    const recommendedCommands = buildWalletNextRecommendedCommands(
+      walletRecord.walletName,
+      summary,
+      resolveEffectivePaymasterSelection(walletRecord)?.mode
+    );
+    const tokenDiscoverySummary = buildWalletTokenDiscoverySummary({
+      walletName: walletRecord.walletName,
+      chain: summary.chain,
+      nextAction: summary.recommendedCommand,
+      paymasterMode: resolveEffectivePaymasterSelection(walletRecord)?.mode,
+      recommendedCommands
+    });
+    printResult(
+      [
+        ...walletStatusLines(inspection, summary),
+        ["discover assets", recommendedCommands.discoverAssets],
+        ["discover owned tokens", recommendedCommands.discoverOwnedTokens],
+        ...recommendedCommands.discoverPaymasterTokens ? [["discover paymaster tokens", recommendedCommands.discoverPaymasterTokens]] : [],
+        ["discover tokens", recommendedCommands.discoverTokens],
+        ...recommendedCommands.inspectPaymasterToken ? [["inspect paymaster token", recommendedCommands.inspectPaymasterToken]] : [],
+        ["inspect token", recommendedCommands.inspectToken],
+        ["wallet next", buildWalletNextRecommendedCommand(walletRecord.walletName)]
+      ],
+      {
+        ok: true,
+        inspection,
+        summary,
+        tokenDiscoverySummary,
+        recommendedCommands
+      }
+    );
   });
   wallet.command("next").description("Explain the shortest next CLI steps to make a stored wallet operational").option("--name <name>", "Wallet name", "main").action(async (options) => {
     const walletRecord = await requireWalletRecord(options.name);
     const { inspection, summary } = await loadWalletStatusSummary(walletRecord, resolvedDeps);
     const recommendedCommands = buildWalletNextRecommendedCommands(
       walletRecord.walletName,
-      summary
+      summary,
+      resolveEffectivePaymasterSelection(walletRecord)?.mode
     );
+    const tokenDiscoverySummary = buildWalletTokenDiscoverySummary({
+      walletName: walletRecord.walletName,
+      chain: summary.chain,
+      nextAction: summary.recommendedCommand,
+      paymasterMode: resolveEffectivePaymasterSelection(walletRecord)?.mode,
+      recommendedCommands
+    });
     printResult(
       [
         ...walletNextLines(summary),
         ["discover assets", recommendedCommands.discoverAssets],
         ["discover owned tokens", recommendedCommands.discoverOwnedTokens],
+        ...recommendedCommands.discoverPaymasterTokens ? [["discover paymaster tokens", recommendedCommands.discoverPaymasterTokens]] : [],
         ["discover tokens", recommendedCommands.discoverTokens],
+        ...recommendedCommands.inspectPaymasterToken ? [["inspect paymaster token", recommendedCommands.inspectPaymasterToken]] : [],
         ["inspect token", recommendedCommands.inspectToken],
         ["status command", recommendedCommands.walletStatus]
       ],
@@ -16101,6 +17362,7 @@ function createWalletCommand(deps) {
         ok: true,
         inspection,
         summary,
+        tokenDiscoverySummary,
         recommendedCommands
       }
     );
@@ -16264,6 +17526,30 @@ function createWalletCommand(deps) {
   request.command("relay-publish").description("Publish a stored wallet request to a relay server and get a shareable approval URL").requiredOption("--request-id <id>", "Wallet request id").requiredOption("--relay-url <url>", "Relay server base URL").action(async (options) => {
     const walletRequest = await requireActiveWalletRequest(options.requestId);
     const relay = await publishWalletRequestToRelay(walletRequest, options.relayUrl);
+    const nextAction = buildWalletRequestRelayStatusRecommendedCommand(
+      relay.request_id,
+      options.relayUrl
+    );
+    const recommendedCommands = {
+      status: buildWalletRequestRelayStatusRecommendedCommand(
+        relay.request_id,
+        options.relayUrl
+      ),
+      approve: buildWalletRequestRelayApproveRecommendedCommand(
+        relay.request_id,
+        options.relayUrl
+      )
+    };
+    const relayRecoverySummary = buildRelayRecoverySummary({
+      requestId: relay.request_id,
+      walletName: walletRequest.walletName,
+      relayUrl: options.relayUrl,
+      relayStatus: relay.status,
+      approvalReady: null,
+      nextAction,
+      recommendedCommands,
+      relay
+    });
     printResult(
       [
         ["status", relay.status],
@@ -16272,26 +17558,25 @@ function createWalletCommand(deps) {
         ["status url", relay.status_url],
         ["share-link base", relay.share_url.replace(/\/[^/]+$/, "")],
         ["status api base", relay.status_url.replace(/\/[^/]+$/, "")],
-        ["next status", buildWalletRequestRelayStatusRecommendedCommand(relay.request_id, options.relayUrl)],
-        ["next approve", buildWalletRequestRelayApproveRecommendedCommand(relay.request_id, options.relayUrl)]
+        ["next status", recommendedCommands.status],
+        ["next approve", recommendedCommands.approve]
       ],
       {
         ok: true,
         walletRequestId: walletRequest.requestId,
         relay,
         ...relayOutputAliases(relay),
+        relayRecoverySummary,
         request: sanitizeWalletRequestRecord(walletRequest),
-        nextAction: buildWalletRequestRelayStatusRecommendedCommand(relay.request_id, options.relayUrl),
-        recommendedCommands: {
-          status: buildWalletRequestRelayStatusRecommendedCommand(relay.request_id, options.relayUrl),
-          approve: buildWalletRequestRelayApproveRecommendedCommand(relay.request_id, options.relayUrl)
-        }
+        nextAction,
+        recommendedCommands
       }
     );
   });
   request.command("relay-status").description("Inspect the relay status of a published wallet request, optionally waiting until approval is ready").requiredOption("--request-id <id>", "Wallet request id").requiredOption("--relay-url <url>", "Relay server base URL").option("--wait", "Poll until the encrypted relay approval is ready or the request expires").option("--timeout-seconds <seconds>", "How long to wait while polling relay status", "600").option("--interval-ms <milliseconds>", "How often to poll relay status while waiting", "2000").action(async (options) => {
     const timeoutMs = parsePositiveIntegerOption(options.timeoutSeconds, "--timeout-seconds", 600) * 1e3;
     const intervalMs = parsePositiveIntegerOption(options.intervalMs, "--interval-ms", 2e3);
+    const walletRequest = await loadWalletRequest(options.requestId);
     let relay;
     try {
       relay = options.wait ? await waitForRelayApprovalReady(options.relayUrl, options.requestId, {
@@ -16302,6 +17587,7 @@ function createWalletCommand(deps) {
       if (options.wait && error instanceof Error && error.message.startsWith("Timed out waiting for relay approval after ")) {
         throw buildRelayApprovalTimeoutError({
           requestId: options.requestId,
+          walletName: walletRequest?.walletName,
           relayUrl: options.relayUrl,
           timeoutMs,
           intervalMs
@@ -16313,6 +17599,16 @@ function createWalletCommand(deps) {
       relay,
       relayUrl: options.relayUrl
     });
+    const relayRecoverySummary = buildRelayRecoverySummary({
+      requestId: relay.request_id,
+      walletName: relay.request?.walletName || walletRequest?.walletName,
+      relayUrl: options.relayUrl,
+      relayStatus: relay.status,
+      approvalReady: relay.approval_ready,
+      nextAction: followUp.nextAction,
+      recommendedCommands: followUp.recommendedCommands,
+      relay
+    });
     printResult(
       [
         ["status", relay.status],
@@ -16334,6 +17630,7 @@ function createWalletCommand(deps) {
         walletRequestId: relay.request_id,
         relay,
         ...relayOutputAliases(relay),
+        relayRecoverySummary,
         nextAction: followUp.nextAction,
         recommendedCommands: followUp.recommendedCommands,
         ...followUp.note ? { note: followUp.note } : {}
@@ -18022,7 +19319,7 @@ function createWalletCommand(deps) {
 
 // src/commands/workflow.ts
 import { randomBytes as randomBytes4 } from "node:crypto";
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 var defaultProvider2 = new ZkSyncWalletProvider();
 var defaultDefiProvider2 = new ZkSyncDefiProvider({
   walletWriter: defaultProvider2
@@ -18662,7 +19959,69 @@ function withAgentProfileLines(lines, agentProfile, agentFollowup) {
     ...agentFollowup ? agentFollowupLines(agentFollowup) : []
   ];
 }
-async function printWorkflowRunCommandResult(execution) {
+function serializeWorkflowFundingProgress(fundingProgress) {
+  return fundingProgress ? {
+    kind: fundingProgress.kind,
+    txHash: fundingProgress.txHash,
+    status: fundingProgress.status,
+    terminal: fundingProgress.terminal,
+    finalized: fundingProgress.finalized
+  } : void 0;
+}
+function buildWorkflowRuntimeSummary(options) {
+  if (!options.status && !options.result) {
+    throw new Error("Workflow runtime summary requires a workflow status or execution result.");
+  }
+  const nextCommand = options.nextCommand ?? options.result?.nextCommand ?? options.status?.fundingProgress?.nextCommand ?? options.status?.recommendedCommand;
+  return {
+    status: options.result?.stage ?? options.status?.status ?? "blocked",
+    readyForGoal: options.result ? options.result.stage === "goal-executed" : Boolean(options.status?.readyForGoal),
+    nextCommand,
+    blockingActionIds: options.status?.blockingActionIds ?? [],
+    fundingProgress: serializeWorkflowFundingProgress(options.status?.fundingProgress)
+  };
+}
+function buildWorkflowEntrySummary(input) {
+  if (input.plan) {
+    return {
+      entrypoint: "workflow",
+      command: input.command,
+      source: input.source || null,
+      workflowRequestId: input.requestId || null,
+      walletName: input.plan.walletName,
+      intent: input.plan.intent,
+      runtimeStatus: input.plan.status,
+      readyForGoal: input.plan.readyForGoal,
+      walletApprovalStatus: null,
+      checkpointPersisted: typeof input.checkpointPersisted === "boolean" ? input.checkpointPersisted : null,
+      nextAction: input.nextCommand || input.plan.recommendedCommand || null
+    };
+  }
+  const runtimeSummary = buildWorkflowRuntimeSummary({
+    status: input.status,
+    result: input.result,
+    nextCommand: input.nextCommand
+  });
+  const walletName = input.result?.walletName ?? input.status?.walletName;
+  const intent = input.result?.intent ?? input.status?.intent;
+  if (!walletName || !intent) {
+    throw new Error("Workflow entry summary requires workflow status or execution metadata.");
+  }
+  return {
+    entrypoint: "workflow",
+    command: input.command,
+    source: input.source || null,
+    workflowRequestId: input.requestId || null,
+    walletName,
+    intent,
+    runtimeStatus: runtimeSummary.status,
+    readyForGoal: runtimeSummary.readyForGoal,
+    walletApprovalStatus: buildWorkflowWalletApprovalSummary(input.walletApproval)?.status || null,
+    checkpointPersisted: typeof input.checkpointPersisted === "boolean" ? input.checkpointPersisted : null,
+    nextAction: runtimeSummary.nextCommand || null
+  };
+}
+async function printWorkflowRunCommandResult(execution, command) {
   if (execution.result) {
     const agentProfile2 = await loadWorkflowAgentProfile(execution.result.walletName);
     const agentFollowup2 = buildAgentFollowup(agentProfile2, {
@@ -18677,6 +20036,29 @@ async function printWorkflowRunCommandResult(execution) {
       intent: execution.result.intent,
       paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal)
     });
+    const tokenDiscoverySummary2 = buildWorkflowTokenDiscoverySummary({
+      walletName: execution.result.walletName,
+      chain: execution.result.plan.chain,
+      intent: execution.result.intent,
+      nextAction: execution.result.nextCommand,
+      paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal),
+      recommendedCommands: recommendedCommands2
+    });
+    const summary2 = buildWorkflowRuntimeSummary({
+      status: execution.status,
+      result: execution.result,
+      nextCommand: execution.result.nextCommand
+    });
+    const workflowEntrySummary2 = buildWorkflowEntrySummary({
+      command,
+      source: execution.requestId ? "checkpoint" : "input",
+      requestId: execution.requestId,
+      checkpointPersisted: Boolean(execution.checkpoint || execution.requestId),
+      status: execution.status,
+      result: execution.result,
+      walletApproval: execution.walletApproval,
+      nextCommand: execution.result.nextCommand
+    });
     printResult(
       prependWorkflowRequestId(
         execution.requestId,
@@ -18693,38 +20075,62 @@ async function printWorkflowRunCommandResult(execution) {
       {
         ok: true,
         ...serializeWorkflowRequestMeta(execution.requestId),
+        workflowEntrySummary: workflowEntrySummary2,
         agentProfile: agentProfile2,
         agentFollowup: agentFollowup2,
+        summary: summary2,
         result: execution.result,
-        walletRequestId: execution.walletApproval?.request.requestId,
-        walletApprovalRelay: execution.walletApproval?.relay,
-        ...workflowWalletApprovalRelayAliases(execution.walletApproval?.relay),
-        walletApprovalRecommendedCommands: execution.walletApproval?.recommendedCommands,
-        walletApproval: serializeWalletApproval(execution.walletApproval),
+        ...serializeWorkflowWalletApprovalOutput(execution.walletApproval),
+        tokenDiscoverySummary: tokenDiscoverySummary2,
         recommendedCommands: recommendedCommands2
       }
     );
     return;
   }
-  const agentProfile = await loadWorkflowAgentProfile(execution.status.walletName);
+  const status = execution.status;
+  if (!status) {
+    throw new Error("Workflow run result is missing both execution result and status.");
+  }
+  const agentProfile = await loadWorkflowAgentProfile(status.walletName);
   const agentFollowup = buildAgentFollowup(agentProfile, {
-    walletName: execution.status.walletName,
+    walletName: status.walletName,
     walletExists: true
   });
   const recommendedCommands = buildWorkflowRuntimeRecommendedCommands({
     requestId: execution.requestId,
-    walletName: execution.status.walletName,
-    nextAction: execution.status.recommendedCommand,
-    chain: execution.status.plan.chain,
-    intent: execution.status.intent,
+    walletName: status.walletName,
+    nextAction: status.recommendedCommand,
+    chain: status.plan.chain,
+    intent: status.intent,
     paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal)
   });
+  const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+    walletName: status.walletName,
+    chain: status.plan.chain,
+    intent: status.intent,
+    nextAction: status.recommendedCommand,
+    paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal),
+    recommendedCommands
+  });
+  const summary = buildWorkflowRuntimeSummary({
+    status,
+    nextCommand: status.recommendedCommand
+  });
+  const workflowEntrySummary = buildWorkflowEntrySummary({
+    command,
+    source: execution.requestId ? "checkpoint" : "input",
+    requestId: execution.requestId,
+    checkpointPersisted: Boolean(execution.checkpoint || execution.requestId),
+    status,
+    walletApproval: execution.walletApproval,
+    nextCommand: status.recommendedCommand
+  });
   printResult(
     prependWorkflowRequestId(
       execution.requestId,
       withAgentProfileLines(
         [
-          ...workflowStatusLines(execution.status),
+          ...workflowStatusLines(status),
           ...workflowWalletApprovalLines(execution.walletApproval),
           ...workflowFollowupLines(recommendedCommands)
         ],
@@ -18735,15 +20141,14 @@ async function printWorkflowRunCommandResult(execution) {
     {
       ok: true,
       ...serializeWorkflowRequestMeta(execution.requestId),
+      workflowEntrySummary,
       agentProfile,
       agentFollowup,
-      status: execution.status,
+      summary,
+      status,
       checkpoint: execution.checkpoint,
-      walletRequestId: execution.walletApproval?.request.requestId,
-      walletApprovalRelay: execution.walletApproval?.relay,
-      ...workflowWalletApprovalRelayAliases(execution.walletApproval?.relay),
-      walletApprovalRecommendedCommands: execution.walletApproval?.recommendedCommands,
-      walletApproval: serializeWalletApproval(execution.walletApproval),
+      ...serializeWorkflowWalletApprovalOutput(execution.walletApproval),
+      tokenDiscoverySummary,
       recommendedCommands
     }
   );
@@ -18996,7 +20401,7 @@ async function executeWorkflowAutoCommand(options, deps = resolveWorkflowCommand
     walletApproval
   };
 }
-async function printWorkflowAutoCommandResult(execution) {
+async function printWorkflowAutoCommandResult(execution, command) {
   const agentProfile = await loadWorkflowAgentProfile(execution.status.walletName);
   const agentFollowup = buildAgentFollowup(agentProfile, {
     walletName: execution.status.walletName,
@@ -19011,6 +20416,29 @@ async function printWorkflowAutoCommandResult(execution) {
     intent: execution.status.intent,
     paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal) ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal)
   });
+  const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+    walletName: execution.status.walletName,
+    chain: execution.status.plan.chain,
+    intent: execution.status.intent,
+    nextAction,
+    paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal) ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal),
+    recommendedCommands
+  });
+  const summary = buildWorkflowRuntimeSummary({
+    status: execution.status,
+    result: execution.result,
+    nextCommand: nextAction
+  });
+  const workflowEntrySummary = buildWorkflowEntrySummary({
+    command,
+    source: execution.source,
+    requestId: execution.requestId,
+    checkpointPersisted: execution.checkpointPersisted,
+    status: execution.status,
+    result: execution.result,
+    walletApproval: execution.walletApproval,
+    nextCommand: nextAction
+  });
   const summaryLines = [
     ["source", execution.source],
     ["action", execution.action],
@@ -19037,16 +20465,15 @@ async function printWorkflowAutoCommandResult(execution) {
       action: execution.action,
       checkpointPersisted: execution.checkpointPersisted,
       ...serializeWorkflowRequestMeta(execution.requestId),
+      workflowEntrySummary,
       agentProfile,
       agentFollowup,
+      summary,
       status: execution.status,
       result: execution.result,
       checkpoint: execution.checkpoint,
-      walletRequestId: execution.walletApproval?.request.requestId,
-      walletApprovalRelay: execution.walletApproval?.relay,
-      ...workflowWalletApprovalRelayAliases(execution.walletApproval?.relay),
-      walletApprovalRecommendedCommands: execution.walletApproval?.recommendedCommands,
-      walletApproval: serializeWalletApproval(execution.walletApproval),
+      ...serializeWorkflowWalletApprovalOutput(execution.walletApproval),
+      tokenDiscoverySummary,
       recommendedCommands
     }
   );
@@ -19102,7 +20529,7 @@ function buildWorkflowRuntimeRecommendedCommands(input) {
     ...input.nextAction ? {
       nextAction: input.nextAction
     } : {},
-    ...input.chain && input.intent && workflowIntentSupportsTokenDiscovery2(input.intent) ? {
+    ...input.chain && input.intent && workflowIntentSupportsTokenDiscovery3(input.intent) ? {
       ...input.walletName ? {
         discoverAssets: `zk-agent assets --wallet ${input.walletName}`,
         discoverOwnedTokens: `zk-agent tokens --wallet ${input.walletName} --owned`
@@ -19116,16 +20543,54 @@ function buildWorkflowRuntimeRecommendedCommands(input) {
     } : {}
   };
 }
-function workflowIntentSupportsTokenDiscovery2(intent) {
+function workflowIntentSupportsTokenDiscovery3(intent) {
   return intent === "send-token" || intent === "swap" || intent === "bridge" || intent === "deposit" || intent === "withdraw";
 }
+function buildWorkflowTokenDiscoverySummary(input) {
+  if (!input.recommendedCommands) {
+    return void 0;
+  }
+  const hasTokenDiscovery = Boolean(input.recommendedCommands.discoverAssets) || Boolean(input.recommendedCommands.discoverOwnedTokens) || Boolean(input.recommendedCommands.discoverTokens) || Boolean(input.recommendedCommands.inspectToken) || Boolean(input.recommendedCommands.discoverPaymasterTokens) || Boolean(input.recommendedCommands.inspectPaymasterToken);
+  if (!hasTokenDiscovery) {
+    return void 0;
+  }
+  return {
+    walletName: input.walletName || null,
+    chain: input.chain || null,
+    intent: input.intent || null,
+    nextAction: input.nextAction || null,
+    paymasterMode: input.paymasterMode || null,
+    tokenizedIntent: input.intent ? workflowIntentSupportsTokenDiscovery3(input.intent) : false,
+    includesAssetDiscovery: Boolean(input.recommendedCommands.discoverAssets),
+    includesOwnedTokenDiscovery: Boolean(input.recommendedCommands.discoverOwnedTokens),
+    includesChainTokenDiscovery: Boolean(input.recommendedCommands.discoverTokens),
+    includesDirectTokenInspection: Boolean(input.recommendedCommands.inspectToken),
+    includesPaymasterTokenDiscovery: Boolean(
+      input.recommendedCommands.discoverPaymasterTokens
+    ),
+    includesPaymasterTokenInspection: Boolean(
+      input.recommendedCommands.inspectPaymasterToken
+    )
+  };
+}
+function buildWorkflowTokenInputErrorSummary(input) {
+  return {
+    chain: input.chain || null,
+    queryType: input.tokenAddress ? "address" : input.symbol ? "symbol" : null,
+    query: input.tokenAddress || input.symbol || null,
+    roleFilter: input.role || null,
+    includesChainTokenDiscovery: Boolean(input.recommendedCommands.discoverTokens),
+    includesDirectTokenInspection: Boolean(input.recommendedCommands.inspectToken),
+    workflowHelp: input.recommendedCommands.workflowHelp
+  };
+}
 function buildWorkflowPlanRecommendedCommands(plan) {
   return {
     inspectDefaults: "zk-agent defaults",
     next: plan.recommendedCommand,
     goal: plan.goalCommand,
     workflowHelp: "zk-agent workflow --help",
-    ...workflowIntentSupportsTokenDiscovery2(plan.intent) ? {
+    ...workflowIntentSupportsTokenDiscovery3(plan.intent) ? {
       discoverAssets: buildAssetsRecommendedCommand(plan.walletName),
       discoverOwnedTokens: buildOwnedTokensRecommendedCommand(plan.walletName),
       discoverTokens: buildTokensRecommendedCommand(plan.chain),
@@ -19169,6 +20634,13 @@ function buildWorkflowTokenErrorRecommendedCommands(error) {
 }
 function printWorkflowTokenInputError(error) {
   const recommendedCommands = buildWorkflowTokenErrorRecommendedCommands(error);
+  const tokenDiscoverySummary = buildWorkflowTokenInputErrorSummary({
+    chain: typeof error.details?.chain === "string" ? error.details.chain : void 0,
+    symbol: typeof error.details?.symbol === "string" ? error.details.symbol : void 0,
+    tokenAddress: typeof error.details?.tokenAddress === "string" ? error.details.tokenAddress : void 0,
+    role: typeof error.details?.role === "string" ? error.details.role : void 0,
+    recommendedCommands
+  });
   const lines = [["error", error.message], ["code", error.code]];
   if (typeof error.details?.suggestedAction === "string" && error.details.suggestedAction.length > 0) {
     lines.push(["suggested action", error.details.suggestedAction]);
@@ -19176,6 +20648,7 @@ function printWorkflowTokenInputError(error) {
   lines.push(...workflowFollowupLines(recommendedCommands));
   printResult(lines, {
     ...formatErrorPayload(error),
+    tokenDiscoverySummary,
     recommendedCommands
   });
   process.exitCode = 1;
@@ -19197,6 +20670,7 @@ function serializeWalletApproval(walletApproval) {
   if (!walletApproval) return void 0;
   return {
     ...walletApproval,
+    summary: buildWorkflowWalletApprovalSummary(walletApproval),
     ...workflowWalletApprovalRelayAliases(walletApproval.relay, {
       shareLinkBaseField: "relayShareLinkBaseUrl",
       statusApiBaseField: "relayStatusApiBaseUrl"
@@ -19206,6 +20680,34 @@ function serializeWalletApproval(walletApproval) {
     wallet: walletApproval.wallet ? sanitizeWalletRecord(walletApproval.wallet) : void 0
   };
 }
+function buildWorkflowWalletApprovalSummary(walletApproval) {
+  if (!walletApproval) return void 0;
+  let status = "await-local";
+  if (walletApproval.stage === "approved") {
+    status = "approved";
+  } else if (walletApproval.recommendedCommands?.relayStatus && walletApproval.nextCommand === walletApproval.recommendedCommands.relayStatus) {
+    status = "relay-pending";
+  }
+  return {
+    status,
+    walletRequestId: walletApproval.request.requestId,
+    reusedRequest: walletApproval.reusedRequest,
+    relayPublished: Boolean(walletApproval.relay),
+    nextAction: walletApproval.nextCommand,
+    afterApproval: walletApproval.recommendedCommands?.afterApproval || null,
+    afterApprovalStatus: walletApproval.recommendedCommands?.afterApprovalStatus || null
+  };
+}
+function serializeWorkflowWalletApprovalOutput(walletApproval) {
+  return {
+    walletRequestId: walletApproval?.request.requestId,
+    walletApprovalRelay: walletApproval?.relay,
+    ...workflowWalletApprovalRelayAliases(walletApproval?.relay),
+    walletApprovalRecommendedCommands: walletApproval?.recommendedCommands,
+    walletApprovalSummary: buildWorkflowWalletApprovalSummary(walletApproval),
+    walletApproval: serializeWalletApproval(walletApproval)
+  };
+}
 function workflowWalletApprovalRelayAliases(relay, fieldNames = {
   shareLinkBaseField: "walletApprovalRelayShareLinkBaseUrl",
   statusApiBaseField: "walletApprovalRelayStatusApiBaseUrl"
@@ -19557,7 +21059,7 @@ function applyWorkflowHelpCommandOrder(workflow) {
 }
 function createWorkflowCommand(deps) {
   const resolvedDeps = resolveWorkflowCommandDeps(deps);
-  const workflow = new Command10("workflow").description(
+  const workflow = new Command11("workflow").description(
     "Plan, persist, and execute higher-level wallet workflows"
   );
   workflow.addHelpText("after", buildWorkflowHelpText());
@@ -19583,11 +21085,26 @@ function createWorkflowCommand(deps) {
         ...plan,
         paymasterMode: paymasterInput?.mode
       });
+      const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+        walletName: plan.walletName,
+        chain: plan.chain,
+        intent: plan.intent,
+        paymasterMode: paymasterInput?.mode,
+        nextAction: plan.recommendedCommand,
+        recommendedCommands
+      });
       const agentProfile = await loadWorkflowAgentProfile(plan.walletName);
       const agentFollowup = buildAgentFollowup(agentProfile, {
         walletName: plan.walletName,
         walletExists: true
       });
+      const workflowEntrySummary = buildWorkflowEntrySummary({
+        command: "plan",
+        source: "input",
+        checkpointPersisted: false,
+        plan,
+        nextCommand: plan.recommendedCommand
+      });
       printResult(
         withAgentProfileLines(
           [...workflowPlanLines(plan), ...workflowFollowupLines(recommendedCommands)],
@@ -19596,10 +21113,12 @@ function createWorkflowCommand(deps) {
         ),
         {
           ok: true,
+          workflowEntrySummary,
           agentProfile,
           agentFollowup,
           inspection,
           plan,
+          tokenDiscoverySummary,
           recommendedCommands
         }
       );
@@ -19736,6 +21255,14 @@ function createWorkflowCommand(deps) {
       {
         ok: true,
         ...serializeWorkflowRequestMeta(started.requestId),
+        workflowEntrySummary: buildWorkflowEntrySummary({
+          command: "start",
+          source: "input",
+          requestId: started.requestId,
+          checkpointPersisted: true,
+          status: started.status,
+          nextCommand: started.status.recommendedCommand
+        }),
         agentProfile,
         agentFollowup,
         checkpoint: started.checkpoint,
@@ -19755,7 +21282,7 @@ function createWorkflowCommand(deps) {
     includeLocalApproval: true
   }).action(withWorkflowInputErrorHandling(async (options) => {
     const execution = await executeWorkflowAutoCommand(options, resolvedDeps);
-    await printWorkflowAutoCommandResult(execution);
+    await printWorkflowAutoCommandResult(execution, "auto");
   }));
   const pay = workflow.command("pay").description(
     "Guided flagship AA native-send path with checkpoint persistence, intent-scoped session recovery, and paymaster-aware defaults"
@@ -19772,7 +21299,7 @@ function createWorkflowCommand(deps) {
       applyWorkflowPayDefaults(options),
       resolvedDeps
     );
-    await printWorkflowAutoCommandResult(execution);
+    await printWorkflowAutoCommandResult(execution, "pay");
   }));
   const run = workflow.command("run").description("Run the requested workflow, or stop on the next required prerequisite or funding step first").option(
     "--intent <intent>",
@@ -19784,7 +21311,7 @@ function createWorkflowCommand(deps) {
     includeLocalApproval: true
   }).action(withWorkflowInputErrorHandling(async (options) => {
     const execution = await executeWorkflowRunCommand(options, resolvedDeps);
-    await printWorkflowRunCommandResult(execution);
+    await printWorkflowRunCommandResult(execution, "run");
   }));
   const status = workflow.command("status").description("Inspect whether a workflow is blocked, still waiting on funding, or ready to resume").option(
     "--intent <intent>",
@@ -19803,11 +21330,32 @@ function createWorkflowCommand(deps) {
       intent: inspection.result.intent,
       paymasterMode: inspection.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(inspection.checkpoint?.goal)
     });
+    const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+      walletName: inspection.result.walletName,
+      chain: inspection.result.plan.chain,
+      intent: inspection.result.intent,
+      nextAction: inspection.result.recommendedCommand,
+      paymasterMode: inspection.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(inspection.checkpoint?.goal),
+      recommendedCommands
+    });
     const agentProfile = await loadWorkflowAgentProfile(inspection.result.walletName);
     const agentFollowup = buildAgentFollowup(agentProfile, {
       walletName: inspection.result.walletName,
       walletExists: true
     });
+    const summary = buildWorkflowRuntimeSummary({
+      status: inspection.result,
+      nextCommand: inspection.result.recommendedCommand
+    });
+    const workflowEntrySummary = buildWorkflowEntrySummary({
+      command: "status",
+      source: options.requestId?.trim() ? "checkpoint" : "input",
+      requestId: inspection.requestId,
+      checkpointPersisted: Boolean(inspection.checkpoint),
+      status: inspection.result,
+      walletApproval: inspection.walletApproval,
+      nextCommand: inspection.result.recommendedCommand
+    });
     printResult(
       prependWorkflowRequestId(
         inspection.requestId,
@@ -19824,15 +21372,14 @@ function createWorkflowCommand(deps) {
       {
         ok: true,
         ...serializeWorkflowRequestMeta(inspection.requestId),
+        workflowEntrySummary,
         agentProfile,
         agentFollowup,
+        summary,
         result: inspection.result,
         checkpoint: inspection.checkpoint,
-        walletRequestId: inspection.walletApproval?.request.requestId,
-        walletApprovalRelay: inspection.walletApproval?.relay,
-        ...workflowWalletApprovalRelayAliases(inspection.walletApproval?.relay),
-        walletApprovalRecommendedCommands: inspection.walletApproval?.recommendedCommands,
-        walletApproval: serializeWalletApproval(inspection.walletApproval),
+        ...serializeWorkflowWalletApprovalOutput(inspection.walletApproval),
+        tokenDiscoverySummary,
         recommendedCommands
       }
     );
@@ -19855,11 +21402,32 @@ function createWorkflowCommand(deps) {
       intent: inspection.result.intent,
       paymasterMode: inspection.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(inspection.checkpoint?.goal)
     });
+    const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+      walletName: inspection.result.walletName,
+      chain: inspection.result.plan.chain,
+      intent: inspection.result.intent,
+      nextAction: nextCommand,
+      paymasterMode: inspection.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(inspection.checkpoint?.goal),
+      recommendedCommands
+    });
     const agentProfile = await loadWorkflowAgentProfile(inspection.result.walletName);
     const agentFollowup = buildAgentFollowup(agentProfile, {
       walletName: inspection.result.walletName,
       walletExists: true
     });
+    const summary = buildWorkflowRuntimeSummary({
+      status: inspection.result,
+      nextCommand
+    });
+    const workflowEntrySummary = buildWorkflowEntrySummary({
+      command: "next",
+      source: options.requestId?.trim() ? "checkpoint" : "input",
+      requestId: inspection.requestId,
+      checkpointPersisted: Boolean(inspection.checkpoint),
+      status: inspection.result,
+      walletApproval: inspection.walletApproval,
+      nextCommand
+    });
     printResult(
       prependWorkflowRequestId(
         inspection.requestId,
@@ -19876,28 +21444,14 @@ function createWorkflowCommand(deps) {
       {
         ok: true,
         ...serializeWorkflowRequestMeta(inspection.requestId),
+        workflowEntrySummary,
         agentProfile,
         agentFollowup,
-        summary: {
-          status: inspection.result.status,
-          readyForGoal: inspection.result.readyForGoal,
-          nextCommand,
-          blockingActionIds: inspection.result.blockingActionIds,
-          fundingProgress: inspection.result.fundingProgress ? {
-            kind: inspection.result.fundingProgress.kind,
-            txHash: inspection.result.fundingProgress.txHash,
-            status: inspection.result.fundingProgress.status,
-            terminal: inspection.result.fundingProgress.terminal,
-            finalized: inspection.result.fundingProgress.finalized
-          } : void 0
-        },
+        summary,
         result: inspection.result,
         checkpoint: inspection.checkpoint,
-        walletRequestId: inspection.walletApproval?.request.requestId,
-        walletApprovalRelay: inspection.walletApproval?.relay,
-        ...workflowWalletApprovalRelayAliases(inspection.walletApproval?.relay),
-        walletApprovalRecommendedCommands: inspection.walletApproval?.recommendedCommands,
-        walletApproval: serializeWalletApproval(inspection.walletApproval),
+        ...serializeWorkflowWalletApprovalOutput(inspection.walletApproval),
+        tokenDiscoverySummary,
         recommendedCommands
       }
     );
@@ -19921,11 +21475,32 @@ function createWorkflowCommand(deps) {
         intent: inspection.result.intent,
         paymasterMode: inspection.walletApproval.request.requestedPaymasterMode
       });
+      const tokenDiscoverySummary2 = buildWorkflowTokenDiscoverySummary({
+        walletName: inspection.result.walletName,
+        chain: inspection.result.plan.chain,
+        intent: inspection.result.intent,
+        nextAction: inspection.result.recommendedCommand,
+        paymasterMode: inspection.walletApproval.request.requestedPaymasterMode,
+        recommendedCommands: recommendedCommands2
+      });
       const agentProfile2 = await loadWorkflowAgentProfile(inspection.result.walletName);
       const agentFollowup2 = buildAgentFollowup(agentProfile2, {
         walletName: inspection.result.walletName,
         walletExists: true
       });
+      const summary2 = buildWorkflowRuntimeSummary({
+        status: inspection.result,
+        nextCommand: inspection.result.recommendedCommand
+      });
+      const workflowEntrySummary2 = buildWorkflowEntrySummary({
+        command: "resume",
+        source: options.requestId?.trim() ? "checkpoint" : "input",
+        requestId: inspection.requestId,
+        checkpointPersisted: Boolean(inspection.checkpoint),
+        status: inspection.result,
+        walletApproval: inspection.walletApproval,
+        nextCommand: inspection.result.recommendedCommand
+      });
       printResult(
         prependWorkflowRequestId(
           inspection.requestId,
@@ -19942,15 +21517,14 @@ function createWorkflowCommand(deps) {
         {
           ok: true,
           ...serializeWorkflowRequestMeta(inspection.requestId),
+          workflowEntrySummary: workflowEntrySummary2,
           agentProfile: agentProfile2,
           agentFollowup: agentFollowup2,
+          summary: summary2,
           status: inspection.result,
           checkpoint: inspection.checkpoint,
-          walletRequestId: inspection.walletApproval.request.requestId,
-          walletApprovalRelay: inspection.walletApproval.relay,
-          ...workflowWalletApprovalRelayAliases(inspection.walletApproval.relay),
-          walletApprovalRecommendedCommands: inspection.walletApproval.recommendedCommands,
-          walletApproval: serializeWalletApproval(inspection.walletApproval),
+          ...serializeWorkflowWalletApprovalOutput(inspection.walletApproval),
+          tokenDiscoverySummary: tokenDiscoverySummary2,
           recommendedCommands: recommendedCommands2
         }
       );
@@ -19965,25 +21539,50 @@ function createWorkflowCommand(deps) {
       resolvedDeps
     );
     if (!execution.result) {
+      const status2 = execution.status;
+      if (!status2) {
+        throw new Error("Workflow resume result is missing both execution result and status.");
+      }
       const recommendedCommands2 = buildWorkflowRuntimeRecommendedCommands({
         requestId: execution.requestId,
-        walletName: execution.status.walletName,
-        nextAction: execution.status.recommendedCommand,
-        chain: execution.status.plan.chain,
-        intent: execution.status.intent,
+        walletName: status2.walletName,
+        nextAction: status2.recommendedCommand,
+        chain: status2.plan.chain,
+        intent: status2.intent,
         paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal)
       });
-      const agentProfile2 = await loadWorkflowAgentProfile(execution.status.walletName);
+      const tokenDiscoverySummary2 = buildWorkflowTokenDiscoverySummary({
+        walletName: status2.walletName,
+        chain: status2.plan.chain,
+        intent: status2.intent,
+        nextAction: status2.recommendedCommand,
+        paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.checkpoint?.goal),
+        recommendedCommands: recommendedCommands2
+      });
+      const agentProfile2 = await loadWorkflowAgentProfile(status2.walletName);
       const agentFollowup2 = buildAgentFollowup(agentProfile2, {
-        walletName: execution.status.walletName,
+        walletName: status2.walletName,
         walletExists: true
       });
+      const summary2 = buildWorkflowRuntimeSummary({
+        status: status2,
+        nextCommand: status2.recommendedCommand
+      });
+      const workflowEntrySummary2 = buildWorkflowEntrySummary({
+        command: "resume",
+        source: options.requestId?.trim() ? "checkpoint" : "input",
+        requestId: execution.requestId,
+        checkpointPersisted: Boolean(execution.checkpoint || execution.requestId),
+        status: status2,
+        walletApproval: execution.walletApproval,
+        nextCommand: status2.recommendedCommand
+      });
       printResult(
         prependWorkflowRequestId(
           execution.requestId,
           withAgentProfileLines(
             [
-              ...workflowStatusLines(execution.status),
+              ...workflowStatusLines(status2),
               ...workflowWalletApprovalLines(execution.walletApproval),
               ...workflowFollowupLines(recommendedCommands2)
             ],
@@ -19994,15 +21593,14 @@ function createWorkflowCommand(deps) {
         {
           ok: true,
           ...serializeWorkflowRequestMeta(execution.requestId),
+          workflowEntrySummary: workflowEntrySummary2,
           agentProfile: agentProfile2,
           agentFollowup: agentFollowup2,
-          status: execution.status,
+          summary: summary2,
+          status: status2,
           checkpoint: execution.checkpoint,
-          walletRequestId: execution.walletApproval?.request.requestId,
-          walletApprovalRelay: execution.walletApproval?.relay,
-          ...workflowWalletApprovalRelayAliases(execution.walletApproval?.relay),
-          walletApprovalRecommendedCommands: execution.walletApproval?.recommendedCommands,
-          walletApproval: serializeWalletApproval(execution.walletApproval),
+          ...serializeWorkflowWalletApprovalOutput(execution.walletApproval),
+          tokenDiscoverySummary: tokenDiscoverySummary2,
           recommendedCommands: recommendedCommands2
         }
       );
@@ -20016,11 +21614,34 @@ function createWorkflowCommand(deps) {
       intent: execution.result.intent,
       paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal)
     });
+    const tokenDiscoverySummary = buildWorkflowTokenDiscoverySummary({
+      walletName: execution.result.walletName,
+      chain: execution.result.plan.chain,
+      intent: execution.result.intent,
+      nextAction: execution.result.nextCommand,
+      paymasterMode: execution.walletApproval?.request.requestedPaymasterMode ?? extractWorkflowGoalPaymasterMode(execution.goal),
+      recommendedCommands
+    });
     const agentProfile = await loadWorkflowAgentProfile(execution.result.walletName);
     const agentFollowup = buildAgentFollowup(agentProfile, {
       walletName: execution.result.walletName,
       walletExists: true
     });
+    const summary = buildWorkflowRuntimeSummary({
+      status: inspection.result,
+      result: execution.result,
+      nextCommand: execution.result.nextCommand ?? inspection.result.recommendedCommand
+    });
+    const workflowEntrySummary = buildWorkflowEntrySummary({
+      command: "resume",
+      source: options.requestId?.trim() ? "checkpoint" : "input",
+      requestId: execution.requestId,
+      checkpointPersisted: Boolean(execution.checkpoint || execution.requestId),
+      status: inspection.result,
+      result: execution.result,
+      walletApproval: inspection.walletApproval,
+      nextCommand: execution.result.nextCommand ?? inspection.result.recommendedCommand
+    });
     printResult(
       prependWorkflowRequestId(
         execution.requestId,
@@ -20037,15 +21658,14 @@ function createWorkflowCommand(deps) {
       {
         ok: true,
         ...serializeWorkflowRequestMeta(execution.requestId),
+        workflowEntrySummary,
         agentProfile,
         agentFollowup,
+        summary,
         status: inspection.result,
         result: execution.result,
-        walletRequestId: inspection.walletApproval?.request.requestId,
-        walletApprovalRelay: inspection.walletApproval?.relay,
-        ...workflowWalletApprovalRelayAliases(inspection.walletApproval?.relay),
-        walletApprovalRecommendedCommands: inspection.walletApproval?.recommendedCommands,
-        walletApproval: serializeWalletApproval(inspection.walletApproval),
+        ...serializeWorkflowWalletApprovalOutput(inspection.walletApproval),
+        tokenDiscoverySummary,
         recommendedCommands
       }
     );
@@ -20064,7 +21684,7 @@ function createWorkflowCommand(deps) {
         },
         resolvedDeps
       );
-      await printWorkflowRunCommandResult(execution);
+      await printWorkflowRunCommandResult(execution, intent);
     }));
   }
   workflow.addCommand(
@@ -20093,6 +21713,13 @@ function buildDefaultOperatorPathHelpText() {
     "  zk-agent next",
     `  ${buildWorkflowPayRecommendedCommand("main")}`,
     "",
+    "Validated first-run baseline:",
+    "  setup defaults to zksync-sepolia and the local connector at http://localhost:4444",
+    "  Override those only when you intentionally target a different chain or connector deployment.",
+    "",
+    "If local setup or wallet state is unclear:",
+    "  zk-agent doctor",
+    "",
     "No custom .env is required for setup, next, or wallet create/reapprove request generation.",
     "Add RPC env vars later, before live reads or broadcasts.",
     "",
@@ -20103,6 +21730,7 @@ function buildDefaultOperatorPathHelpText() {
 }
 var ROOT_HELP_COMMAND_ORDER = [
   "next",
+  "doctor",
   "init",
   "wallet",
   "workflow",
@@ -20139,13 +21767,14 @@ function applyRootHelpCommandOrder(program) {
   program.commands = sortedCommands;
 }
 function createProgram() {
-  const program = new Command11().name("zk-agent").description(
+  const program = new Command12().name("zk-agent").description(
     "Local-first zkSync Era CLI for wallet approval, workflow execution, and 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";
   });
   program.addCommand(createInitCommand());
   program.addCommand(createNextCommand());
+  program.addCommand(createDoctorCommand());
   program.addCommand(createAgentCommand());
   program.addCommand(createDefaultsCommand());
   program.addCommand(createTokensCommand());