@zktx.io/sui-mcp 0.7.0 → 0.8.0

package/dist/core/session/workflowState.js

@@ -1,80 +1,146 @@
-import { walletConnectionSelection } from "./walletConnection.js";
+import { CONNECTION_RECONCILIATION_MESSAGE, walletConnectionEligibility, usableWalletConnection, connectionHasSuiSigningScope, projectWalletConnection } from "./walletConnection.js";
 import { isInitialChainObservation } from "./transactionRequest.js";
-export const workflowActions = ["connect", "disconnect", "use_account", "stop_connection", "prepare_review",
+import { SUI_MAINNET_WALLET_CHAIN } from "./chainAccounts.js";
+import { parseSuiAddress } from "../suiAddress.js";
+export const workflowActions = ["connect", "disconnect", "stop_connection", "prepare_review",
     "request_signature", "cancel", "stop_waiting", "read_result"];
-export function reviewPreparationAccount(boundAccount, activeAccount, selectedAccount = activeAccount) {
-    if (!activeAccount)
-        return { allowed: false, message: "No account from a connected wallet is selected for this review." };
-    if (boundAccount && boundAccount !== activeAccount)
-        return { allowed: false,
-            message: `This review uses ${boundAccount}, but the currently selected account is ${activeAccount}.` };
-    if (selectedAccount !== activeAccount)
-        return { allowed: false,
-            message: "The selected account has changed since this request was made." };
-    return { allowed: true, account: activeAccount };
+export const workflowNextSteps = ["none", "wait", "check_status", "open_settings", "request_disconnect", "request_review"];
+function walletServiceNextStep(status) {
+    if (status === "available")
+        return undefined;
+    return { kind: status === "unavailable" ? "open_settings" : "wait", reason: "wallet_unavailable",
+        message: status === "unavailable" ? "Open Settings, then Troubleshooting, to restart the connection service. No wallet request was sent."
+            : "Wait for the connection service to finish starting, then check status." };
+}
+export function walletActionDecision(facts, action, targetId) {
+    const deny = (kind, reason, message) => ({ allowed: false, nextStep: { kind, reason, message } });
+    const service = walletServiceNextStep(facts.walletAvailability.status);
+    if (service)
+        return { allowed: false, nextStep: service };
+    if (facts.pendingOperation)
+        return deny("check_status", "operation_busy", "Wait for the current wallet operation and its cleanup to finish, then check this request's status.");
+    const selection = walletConnectionEligibility(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount, facts.readAddressCleared);
+    if (!facts.connectionPresence.confirmed || !facts.connectionPresence.managed || selection.connectionReconciliationRequired)
+        return deny("check_status", "connection_state_unconfirmed", selection.connectionReconciliationRequired ? CONNECTION_RECONCILIATION_MESSAGE : "The wallet session has not been confirmed. Check its status before continuing.");
+    if (action === "connect") {
+        if (!facts.requestedChains.length)
+            return deny("open_settings", "wallet_networks_required", "Choose networks in Settings before requesting a wallet connection.");
+        return selection.pairingAllowed ? { allowed: true, nextStep: { kind: "none" } }
+            : deny("request_disconnect", "connection_present", "Ask in chat for a Disconnect card before requesting a new wallet connection.");
+    }
+    if (targetId && facts.connection?.connectionId !== targetId)
+        return deny("check_status", "connection_target_changed", "The wallet session for this card is no longer current. Ask in chat for current connection status.");
+    return selection.manageable ? { allowed: true, nextStep: { kind: "none" } }
+        : deny("none", "no_session_to_disconnect", "There is no current wallet session to disconnect. No request was sent.");
+}
+export function fixedReviewTarget(session, input) {
+    const hasInputTarget = input?.connectionId !== undefined || input?.account !== undefined;
+    const inputId = typeof input?.connectionId === "string" && input.connectionId.length ? input.connectionId : undefined;
+    const inputAccount = typeof input?.account === "string" ? parseSuiAddress(input.account) : undefined;
+    if (hasInputTarget && (!inputId || !inputAccount))
+        return undefined;
+    if (inputId && session.walletConnectionId && inputId !== session.walletConnectionId ||
+        inputAccount && session.account && inputAccount !== session.account)
+        return undefined;
+    const connectionId = inputId ?? session.walletConnectionId, account = inputAccount ?? session.account;
+    return connectionId && account ? { connectionId, account } : undefined;
 }
 export function workflowConnectionEligibility(facts) {
-    const selection = walletConnectionSelection(facts.connections, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount ? { address: facts.activeAccount, walletId: facts.activeAccountConnectionId } : undefined);
+    const selection = walletConnectionEligibility(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, facts.activeAccount, facts.readAddressCleared);
     const available = facts.walletAvailability.status === "available", dependent = facts.walletDependent !== false;
-    const usableConnectionId = available && dependent ? selection.connection?.connectionId : undefined;
-    const assetReadAccount = !dependent ? undefined
-        : usableConnectionId ? selection.assetReadAccount : { status: "address_required" };
-    return { selection, usableConnectionId, assetReadAccount, connectionConflict: selection.conflict,
-        manageableConnectionIds: available ? selection.manageableConnectionIds : [],
+    return { selection, usableConnectionId: available && dependent ? selection.connection?.connectionId : undefined,
+        assetReadAccount: !dependent ? undefined : available ? selection.assetReadAccount : { status: "address_required" },
+        connection: projectWalletConnection(facts.connection, Date.parse(facts.evaluatedAt), facts.connectionPresence, available),
+        pendingOperation: facts.pendingOperation,
+        canDisconnect: available && selection.manageable,
         connectionReconciliationRequired: available && dependent ? selection.connectionReconciliationRequired : undefined };
 }
 export function workflowEligibility(facts) {
     const { record, session, request, authority, walletAvailability } = facts;
     const at = Date.parse(facts.evaluatedAt);
-    const cardRemaining = record?.ownerId === facts.ownerId ? Math.max(0, Date.parse(record.state.expiresAt) - at) : 0;
+    const cardRemaining = record?.ownerId === facts.ownerId && record.state.reason !== "cancelled"
+        ? Math.max(0, Date.parse(record.state.expiresAt) - at) : 0;
     const remaining = record?.scope === "review" && session && !request
         ? Math.min(cardRemaining, Math.max(0, Date.parse(session.expiresAt) - at)) : cardRemaining;
     const inputAvailable = remaining > 0 && record?.state.state === "ready" && record.acceptedInput === undefined;
     const allowedActions = [];
     const { selection, ...connectionEligibility } = workflowConnectionEligibility(facts);
-    const { assetReadAccount } = connectionEligibility;
-    let preparationIssue;
-    if (record?.scope === "connect") {
+    const reviewTarget = session && !session.plans[0]?.reviewModel ? fixedReviewTarget(session, record?.state.input) : undefined;
+    const targetId = reviewTarget?.connectionId, targetAccount = reviewTarget?.account;
+    const reviewConnection = walletAvailability.status === "available" && !facts.connectionPresence.unrecorded && facts.walletDependent !== false && targetId && targetAccount
+        ? usableWalletConnection(facts.connection, at, facts.connectionPresence, targetId, SUI_MAINNET_WALLET_CHAIN, targetAccount) : undefined;
+    const preparationIssue = session && record?.scope === "review" && !session.plans[0]?.reviewModel && !reviewTarget
+        ? "This review has no matching fixed wallet target. Start a new review." : undefined;
+    const scopedDisconnect = record?.scope === "disconnect";
+    const walletDecision = walletActionDecision(facts, scopedDisconnect ? "disconnect" : "connect", scopedDisconnect ? String(record?.state.input.connectionId) : undefined);
+    let nextStep = facts.operation?.status === "running" && facts.operation.cardId === record?.state.cardId
+        ? { kind: "wait" } : walletDecision.nextStep;
+    const disconnectTargetMatches = !scopedDisconnect || record.state.input.connectionId === facts.connection?.connectionId;
+    if (record?.scope === "connect" || scopedDisconnect) {
         if (inputAvailable) {
             allowedActions.push("cancel");
             if (walletAvailability.status === "available") {
-                if (["connect", "manage"].includes(String(record.state.input.intent)) && selection.pairingAllowed)
+                if (record.scope === "connect" && walletDecision.allowed)
                     allowedActions.push("connect");
-                if (selection.manageableConnectionIds.length)
+                if (scopedDisconnect && walletDecision.allowed)
                     allowedActions.push("disconnect");
-                if (selection.connection)
-                    allowedActions.push("use_account");
             }
         }
-        if (remaining > 0 && facts.connection?.status === "awaiting_approval")
+        if (record.state.state !== "closed" && remaining > 0 && facts.operation?.action === "connect" && facts.operation.status === "running")
             allowedActions.push("stop_connection");
     }
     if (session && inputAvailable && record?.scope === "review" && session.status !== "expired" && Date.parse(session.expiresAt) > at && !session.preparationId) {
         allowedActions.push("cancel");
-        if (walletAvailability.status === "available" && selection.connection && !session.plans[0]?.reviewModel) {
-            const account = reviewPreparationAccount(session.account, assetReadAccount?.status === "available" ? assetReadAccount.account : undefined);
-            if (!account.allowed)
-                preparationIssue = account.message;
-            else if (!facts.busyForAccount)
+        if (walletAvailability.status === "available" && reviewConnection && !session.plans[0]?.reviewModel) {
+            if (!facts.busyForAccount)
                 allowedActions.push("prepare_review");
-            if (!facts.busyForAccount && session.status === "ready_for_wallet_review" && session.reviewState?.transactionReviewData &&
+            if (!facts.busyForAccount && connectionHasSuiSigningScope(reviewConnection, targetAccount) && session.status === "ready_for_wallet_review" && session.reviewState?.transactionReviewData &&
                 (!request || request.reviewRevision !== session.reviewRevision))
                 allowedActions.push("request_signature");
         }
     }
-    if (record && session && remaining > 0 && request && request.reviewSessionId === session.id &&
+    if (record && record.state.state !== "closed" && session && remaining > 0 && request && request.reviewSessionId === session.id &&
         authority?.owner_id === facts.ownerId &&
         (record.operationId === request.attemptId || record.scope === "review_manage" && record.state.input.attemptId === request.attemptId)) {
-        if (["awaiting_signature", "submitting", "awaiting_chain_result"].includes(request.requestStatus))
+        if (request.requestStatus === "awaiting_signature" || !authority.observation_stopped && isInitialChainObservation(request.requestStatus))
             allowedActions.push("stop_waiting");
-        if (isInitialChainObservation(request.requestStatus) || request.requestStatus === "outcome_unknown")
+        if (record.scope === "review_manage" && record.state.state === "ready" && record.acceptedInput === undefined && (isInitialChainObservation(request.requestStatus) || request.requestStatus === "outcome_unknown"))
             allowedActions.push("read_result");
     }
     const expiry = session && inputAvailable && record?.scope === "review" && !session.preparationId &&
         session.status === "ready_for_wallet_review" && (!request || request.reviewRevision !== session.reviewRevision)
         ? session.reviewState?.humanReadableReview?.freshness.expiresAt : undefined;
-    const nextRead = expiry && session ? Math.min(remaining, Date.parse(session.expiresAt) - at, Date.parse(expiry) - at) : undefined;
-    return { allowedActions, preparationIssue, ...connectionEligibility,
+    const reviewRead = expiry && session ? Math.min(remaining, Date.parse(session.expiresAt) - at, Date.parse(expiry) - at) : undefined;
+    const connectionDeadlines = inputAvailable && facts.walletDependent !== false && facts.connection?.status === "connected" &&
+        (["connect", "disconnect"].includes(record?.scope ?? "") || facts.connection.connectionId === reviewTarget?.connectionId)
+        ? [Date.parse(facts.connection.expiresAt) - at].filter((delay) => delay > 0) : [];
+    const readDelays = [reviewRead, ...connectionDeadlines].filter((delay) => delay !== undefined && delay > 0);
+    const nextRead = readDelays.length ? Math.min(...readDelays) : undefined;
+    if (session) {
+        nextStep = { kind: "none" };
+        if (!session.plans[0]?.reviewModel && !request) {
+            const service = walletServiceNextStep(walletAvailability.status);
+            if (service)
+                nextStep = service;
+            else if (facts.connectionPresence.unrecorded)
+                nextStep = { kind: "check_status", reason: "connection_state_unconfirmed", message: CONNECTION_RECONCILIATION_MESSAGE };
+            else if (facts.pendingOperation)
+                nextStep = { kind: "check_status", reason: "operation_busy", message: "Wait for the current wallet operation and its cleanup to finish, then check this review's status." };
+            else if (reviewTarget && connectionEligibility.connection?.connectionId === targetId && connectionEligibility.connection?.sessionPresence === "absent")
+                nextStep = { kind: "request_review", message: "The original wallet session is no longer present. Reconnect a wallet and ask in chat for a new transaction review." };
+            else if (reviewTarget && facts.connection && facts.connection.connectionId !== targetId)
+                nextStep = { kind: "request_review", message: "This review belongs to the earlier wallet connection. Ask in chat for a new transaction review." };
+            else if (!reviewConnection && connectionEligibility.canDisconnect && facts.connection?.connectionId === targetId)
+                nextStep = { kind: "request_disconnect", message: "The original wallet connection is unavailable. Ask in chat for a Disconnect card, then start a new review after reconnecting." };
+            else if (!reviewConnection)
+                nextStep = { kind: "check_status", message: "This review keeps its original account and connection. Ask in chat to check that wallet connection's status before continuing." };
+            else if (facts.busyForAccount)
+                nextStep = { kind: "wait", message: "A previous transaction request for this Sui account is still pending. Wait for it to finish, then check this review's status." };
+        }
+    }
+    return { allowedActions, preparationIssue, nextStep, ...connectionEligibility, reviewTarget,
+        canDisconnect: connectionEligibility.canDisconnect && disconnectTargetMatches,
+        ...(session ? { usableConnectionId: reviewConnection?.connectionId } : {}),
         actionRemainingMs: remaining, inputRemainingMs: inputAvailable ? remaining : 0,
         ...(nextRead !== undefined && nextRead > 0 ? { nextStateReadAfterMs: nextRead } : {}) };
 }

package/dist/core/session/workflowView.js

@@ -1,84 +1,86 @@
-import { workflowActions } from "./workflowState.js";
+import { workflowActions, workflowNextSteps } from "./workflowState.js";
 import { z } from "zod";
-import { suiAddressStringSchema, parseSuiAddress } from "../suiAddress.js";
+import { suiAddressStringSchema } from "../suiAddress.js";
 import { actionPlanSchema, internalSessionStatusSchema, reviewStateOutputSchema } from "../action/schemas.js";
-import { walletConnectionSchema, walletAvailabilitySchema, workflowProgressSchema, WALLET_CONNECTION_POLL_SECONDS, connectionConflictSchema, assetReadAccountSchema } from "./walletConnection.js";
+import { walletConnectionSchema, walletAvailabilitySchema, workflowProgressSchema, WALLET_CONNECTION_POLL_SECONDS, connectionChainStateSchema } from "./walletConnection.js";
 import { transactionRequestSchema } from "./transactionRequest.js";
 import { workflowProgress } from "./walletConnection.js";
 import { reviewProgress, EXECUTION_POLLING_INTERVAL_SECONDS } from "./status.js";
-import { walletRunIdSchema, walletRecoverySchema, walletObservationSchema } from "./walletRuntime.js";
+import { walletRunIdSchema, walletObservationSchema } from "./walletRuntime.js";
+import { walletConnectionActionSchema, walletConnectionOperationSchema } from "./walletConnectionOperations.js";
+import { walletChainSchema, walletChainsSchema, SUI_MAINNET_WALLET_CHAIN, normalizeChainAddress } from "./chainAccounts.js";
 export const CONNECT_BOUNDARY = "A wallet connection provides account context; it is not a transaction approval or proof of address ownership.";
 export const REVIEW_BOUNDARY = "Review evidence is not a safety guarantee. Only an explicit card action and wallet approval may authorize this exact transaction.";
-export const connectionViewSchema = walletConnectionSchema.extend({ pendingAction: z.literal("disconnect").optional() });
+export const connectionViewSchema = walletConnectionSchema.extend({
+    sessionPresence: z.enum(["present", "absent", "unusable", "unconfirmed"]),
+    chainStates: z.array(connectionChainStateSchema).optional(),
+    disconnectImpact: z.object({ impactId: z.string(), requestCount: z.number().int().nonnegative(), chains: walletChainsSchema }).strict().optional()
+});
 export { assetReadAccountSchema } from "./walletConnection.js";
-export const pendingConnectionStatusSchema = z.enum(["input_required", "awaiting_approval", "disconnect_pending"]);
-const connectAction = z.object({ action: z.literal("connect"), walletRunId: walletRunIdSchema }).strict();
-const disconnectAction = z.object({ action: z.literal("disconnect"), walletRunId: walletRunIdSchema, connectionId: z.string().min(1) }).strict();
-const accountAction = z.object({ action: z.literal("use_account"), walletRunId: walletRunIdSchema, connectionId: z.string().min(1), account: suiAddressStringSchema }).strict();
+export const pendingConnectionStatusSchema = z.enum(["awaiting_approval", "disconnect_pending", "cleanup_pending"]);
 const reviewAction = z.object({ action: z.enum(["prepare_review", "request_signature"]), connectionId: z.string().min(1),
     walletRunId: walletRunIdSchema, account: suiAddressStringSchema, reviewRevision: z.number().int().nonnegative() }).strict();
-const simpleAction = z.object({ action: z.enum(["cancel", "stop_connection", "stop_waiting", "read_result"]) }).strict();
-export const workflowActionSchema = z.union([connectAction, disconnectAction, accountAction, reviewAction, simpleAction]);
-export const automaticWorkflowActionSchema = z.union([connectAction, reviewAction.extend({ action: z.literal("prepare_review") })]);
+const simpleAction = z.object({ action: z.enum(["cancel", "stop_waiting", "read_result"]) }).strict();
+const stopConnectionAction = z.object({ action: z.literal("stop_connection"), operationId: z.string().uuid() }).strict();
+export const workflowActionSchema = z.union([walletConnectionActionSchema, stopConnectionAction, reviewAction, simpleAction]);
+export const automaticWorkflowActionSchema = z.union([walletConnectionActionSchema.options[0], reviewAction.extend({ action: z.literal("prepare_review") })]);
 export function parseWorkflowAction(input) {
     const action = workflowActionSchema.parse(input);
-    return "account" in action ? { ...action, account: parseSuiAddress(action.account) } : action;
-}
-export const workflowViewSchema = z.object({
-    kind: z.enum(["connect", "review"]),
-    mode: z.enum(["connect", "review", "review_manage"]),
-    allowedActions: z.array(z.enum(workflowActions)),
-    actionRemainingMs: z.number().int().nonnegative(),
-    nextStateReadAfterMs: z.number().int().nonnegative().optional(),
-    automaticAction: automaticWorkflowActionSchema.optional(),
-    observe: z.boolean(),
-    walletAvailability: walletAvailabilitySchema,
-    walletObservation: walletObservationSchema.optional(),
-    runtimeRecovery: walletRecoverySchema.optional(),
-    connectionConflict: connectionConflictSchema.optional(),
-    manageableConnectionIds: z.array(z.string().min(1)),
-    connectionReconciliationRequired: z.literal(true).optional(),
-    usableConnectionId: z.string().min(1).optional(),
-    assetReadAccount: assetReadAccountSchema.optional(),
-    acceptedWalletRunId: walletRunIdSchema.optional(),
-    progress: workflowProgressSchema,
-    boundary: z.enum([CONNECT_BOUNDARY, REVIEW_BOUNDARY]),
-    connections: z.array(connectionViewSchema),
-    activeAccount: z.string().optional(),
-    connection: connectionViewSchema.optional(),
-    connectionAction: z.enum(["connect", "disconnect"]).optional(),
-    review: z.object({
-        reviewSessionId: z.string(), plan: actionPlanSchema, reviewRevision: z.number().int().nonnegative(),
-        status: internalSessionStatusSchema, account: z.string().optional(), preparing: z.boolean(),
-        accountRequestPending: z.literal(true).optional(),
-        error: z.string().optional(),
-        state: reviewStateOutputSchema.optional()
-    }).strict().optional(),
-    request: transactionRequestSchema.optional(),
-    receipt: z.unknown().optional(),
-    netGasMist: z.string().regex(/^-?[0-9]+$/).optional(),
-    observationStopped: z.boolean().optional()
-}).strict().superRefine((view, context) => {
-    const connection = view.connections.find((item) => item.connectionId === view.usableConnectionId);
-    if (view.usableConnectionId && (!connection || connection.status !== "connected" ||
-        view.walletAvailability.status !== "available" || view.connectionConflict || view.connectionReconciliationRequired ||
-        view.connections.some((item) => item.pendingAction || item.status === "awaiting_approval"))) {
-        context.addIssue({ code: "custom", path: ["usableConnectionId"], message: "The usable connection must match current connection facts." });
-    }
-    if (new Set(view.manageableConnectionIds).size !== view.manageableConnectionIds.length ||
-        view.manageableConnectionIds.some((id) => !view.connections.some((item) => item.connectionId === id &&
-            !item.pendingAction && item.status !== "awaiting_approval"))) {
-        context.addIssue({ code: "custom", path: ["manageableConnectionIds"], message: "Management must name distinct recorded targets without pending operations." });
+    if ("account" in action) {
+        const account = normalizeChainAddress(SUI_MAINNET_WALLET_CHAIN, action.account);
+        if (!account)
+            throw new Error("A valid chain account is required.");
+        return { ...action, account };
     }
-    if (view.connectionReconciliationRequired && (view.usableConnectionId || view.assetReadAccount?.status === "available" ||
-        view.allowedActions.some((action) => ["connect", "use_account", "prepare_review", "request_signature"].includes(action)))) {
-        context.addIssue({ code: "custom", path: ["connectionReconciliationRequired"], message: "Unrecorded SDK connections cannot authorize connection or account use." });
-    }
-    if (view.assetReadAccount?.status === "available" && (!connection ||
-        !connection.accounts.includes(view.assetReadAccount.account) || view.activeAccount !== view.assetReadAccount.account)) {
-        context.addIssue({ code: "custom", path: ["assetReadAccount"], message: "The default address must belong to the usable connection and stored selection." });
+    return action;
+}
+function checkReviewAccount(view, context) {
+    if (view.reviewTarget && (view.review?.account && view.review.account !== view.reviewTarget.account ||
+        view.request && view.request.account !== view.reviewTarget.account)) {
+        context.addIssue({ code: "custom", path: ["reviewTarget"], message: "The fixed review target must match its recorded account and request." });
     }
-});
+}
+const nextStepSchema = z.object({ kind: z.enum(workflowNextSteps), message: z.string().optional(), reason: z.string().optional() }).strict();
+const liveFields = {
+    allowedActions: z.array(z.enum(workflowActions)), actionRemainingMs: z.number().int().nonnegative(),
+    nextStateReadAfterMs: z.number().int().nonnegative().optional(), observe: z.boolean(),
+    walletAvailability: walletAvailabilitySchema, walletObservation: walletObservationSchema.optional(),
+    progress: workflowProgressSchema, nextStep: nextStepSchema
+};
+export const connectViewSchema = z.object({ ...liveFields, kind: z.literal("connect"), mode: z.literal("connect"),
+    allowedActions: z.array(z.enum(["connect", "cancel", "stop_connection"])),
+    boundary: z.literal(CONNECT_BOUNDARY), requestedChains: walletChainsSchema,
+    operation: walletConnectionOperationSchema.optional(), automaticAction: walletConnectionActionSchema.options[0].optional() }).strict();
+export const disconnectViewSchema = z.object({ ...liveFields, kind: z.literal("disconnect"), mode: z.literal("disconnect"),
+    allowedActions: z.array(z.enum(["disconnect", "cancel"])),
+    boundary: z.literal(CONNECT_BOUNDARY), connection: connectionViewSchema.optional(),
+    operation: walletConnectionOperationSchema.optional() }).strict();
+const reviewPayloadSchema = z.object({
+    reviewSessionId: z.string(), plan: actionPlanSchema, reviewRevision: z.number().int().nonnegative(),
+    status: internalSessionStatusSchema, account: z.string().optional(), preparing: z.boolean(),
+    accountRequestPending: z.literal(true).optional(), error: z.string().optional(), state: reviewStateOutputSchema.optional()
+}).strict();
+const reviewTargetSchema = z.object({ connectionId: z.string(), account: suiAddressStringSchema }).strict();
+const netGasSchema = z.string().regex(/^-?[0-9]+$/).optional();
+export const reviewViewSchema = z.object({ ...liveFields, kind: z.literal("review"), mode: z.enum(["review", "review_manage"]),
+    allowedActions: z.array(z.enum(["prepare_review", "request_signature", "read_result", "stop_waiting", "cancel"])),
+    boundary: z.literal(REVIEW_BOUNDARY), reviewTarget: reviewTargetSchema.optional(), review: reviewPayloadSchema,
+    walletName: z.string().optional(), acceptedWalletRunId: walletRunIdSchema.optional(),
+    automaticAction: reviewAction.extend({ action: z.literal("prepare_review") }).optional(),
+    request: transactionRequestSchema.optional(), receipt: z.unknown().optional(), netGasMist: netGasSchema,
+    observationStopped: z.boolean().optional()
+}).strict().superRefine(checkReviewAccount);
+export const workflowViewSchema = z.discriminatedUnion("kind", [connectViewSchema, disconnectViewSchema, reviewViewSchema]);
+const closedResult = z.object({ message: z.string(), recordedAt: z.string().datetime() }).strict();
+const closedFields = { allowedActions: z.array(z.never()), observe: z.literal(false), actionRemainingMs: z.literal(0), result: closedResult };
+export const closedWalletCardSchema = z.object({ ...closedFields, kind: z.enum(["connect", "disconnect"]),
+    result: closedResult.extend({ pendingWork: z.enum(["approval_response", "session_removal", "session_status"]).optional() }), walletName: z.string().optional(),
+    networks: z.array(z.object({ chainId: walletChainSchema, status: z.enum(["bound", "not_approved", "multiple_accounts", "invalid_response"]) }).strict()) }).strict();
+export const closedReviewCardSchema = z.object({ ...closedFields, kind: z.literal("review"),
+    mode: z.enum(["review", "review_manage"]), review: reviewPayloadSchema.optional(),
+    reviewTarget: reviewTargetSchema.optional(), request: transactionRequestSchema.optional(),
+    receipt: z.unknown().optional(), netGasMist: netGasSchema,
+    observationStopped: z.boolean().optional(), boundary: z.literal(REVIEW_BOUNDARY) }).strict().superRefine(checkReviewAccount);
 function automaticReviewAction(input) {
     const { record, session, request } = input;
     if (!session || record?.scope !== "review" || request || session.preparationError ||
@@ -86,18 +88,11 @@ function automaticReviewAction(input) {
         return undefined;
     const needsPreparation = !session.reviewState && session.reviewRevision === 0 ||
         session.reviewState?.status === "refresh_required" && session.reviewState.refreshReason === "review_evidence_stale";
-    if (!needsPreparation || input.assetReadAccount?.status !== "available")
-        return undefined;
-    const account = input.assetReadAccount.account;
-    const candidates = reviewWalletChoices(input, account);
-    if (candidates.length !== 1)
+    if (!needsPreparation || !input.reviewTarget)
         return undefined;
-    return { action: "prepare_review", walletRunId: input.walletAvailability.walletRunId, connectionId: candidates[0].connectionId,
-        account, reviewRevision: session.reviewRevision };
-}
-export function reviewWalletChoices(selection, account, requireSigningMethod = false) {
-    return selection.connections.filter((item) => item.connectionId === selection.usableConnectionId && item.accounts.includes(account) &&
-        (!requireSigningMethod || item.methods.includes("sui_signTransaction")));
+    const account = input.reviewTarget.account;
+    return { action: "prepare_review", walletRunId: input.walletAvailability.walletRunId,
+        connectionId: input.reviewTarget.connectionId, account, reviewRevision: session.reviewRevision };
 }
 function nextStateRead(input) {
     const walletInput = input.record?.state.state === "ready" && input.record.scope !== "review_manage" && !input.request &&
@@ -109,24 +104,20 @@ function nextStateRead(input) {
     return delays.length ? Math.min(...delays) : undefined;
 }
 export function projectConnectionView(input) {
-    const { walletAvailability } = input;
-    const stored = input.record?.state.data;
-    const connection = input.record?.acceptedInput?.action === "disconnect" && stored?.disconnectOutcome
-        ? connectionViewSchema.parse(stored.disconnectOutcome) : input.connection;
-    const readAfter = nextStateRead(input);
-    const progress = input.runtimeRecovery ? { status: "phase" in input.runtimeRecovery ? "waiting" : "idle" } :
-        workflowProgress(connection?.status === "awaiting_approval" || connection?.pendingAction === "disconnect", true, walletAvailability);
-    return workflowViewSchema.parse({ kind: "connect", mode: "connect", allowedActions: input.allowedActions,
-        actionRemainingMs: input.actionRemainingMs, observe: progress.status === "waiting", progress, walletAvailability,
-        ...(input.record?.state.input.intent === "connect" && input.allowedActions.includes("connect")
-            ? { automaticAction: { action: "connect", walletRunId: walletAvailability.walletRunId } } : {}),
-        runtimeRecovery: input.runtimeRecovery, walletObservation: input.walletObservation,
-        connectionConflict: input.connectionConflict, usableConnectionId: input.usableConnectionId, assetReadAccount: input.assetReadAccount,
-        manageableConnectionIds: input.manageableConnectionIds, connectionReconciliationRequired: input.connectionReconciliationRequired,
-        connectionAction: ["connect", "disconnect"].includes(String(input.record?.acceptedInput?.action)) ? input.record?.acceptedInput?.action : undefined,
-        acceptedWalletRunId: input.record?.acceptedInput?.walletRunId,
-        ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }),
-        connections: input.connections, activeAccount: input.activeAccount, connection, boundary: CONNECT_BOUNDARY });
+    const { walletAvailability, operation } = input, readAfter = nextStateRead(input);
+    const progress = workflowProgress(!!operation && operation.status === "running", true, walletAvailability);
+    const common = { allowedActions: input.allowedActions, actionRemainingMs: input.actionRemainingMs,
+        observe: progress.status === "waiting", progress, walletAvailability, walletObservation: input.walletObservation,
+        operation, nextStep: input.nextStep, boundary: CONNECT_BOUNDARY,
+        ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }) };
+    if (input.record?.scope === "disconnect")
+        return disconnectViewSchema.parse({ ...common, kind: "disconnect", mode: "disconnect",
+            connection: input.connection?.connectionId === input.record.state.input.connectionId ? input.connection : undefined });
+    return connectViewSchema.parse({ ...common, kind: "connect", mode: "connect",
+        requestedChains: walletChainsSchema.parse(input.record?.state.input.requestedChains ?? input.requestedChains),
+        ...(!operation && input.record?.operationId && input.allowedActions.includes("connect")
+            ? { automaticAction: { action: "connect", operationId: input.record.operationId, walletRunId: walletAvailability.walletRunId,
+                    chains: input.record.state.input.requestedChains } } : {}) });
 }
 export function projectReviewView(input) {
     const { record, session, request, authority, walletAvailability, boundReview } = input;
@@ -139,11 +130,11 @@ export function projectReviewView(input) {
     const gas = displayedReview?.simulation?.gasCostSummary;
     const automaticAction = automaticReviewAction(input);
     const readAfter = nextStateRead(input);
-    return workflowViewSchema.parse({ kind: "review", mode: record.scope === "review_manage" ? "review_manage" : "review",
+    return reviewViewSchema.parse({ kind: "review", mode: record.scope === "review_manage" ? "review_manage" : "review",
         allowedActions: input.allowedActions, actionRemainingMs: input.actionRemainingMs, observe: progress.status === "waiting", progress, walletAvailability,
-        connections: input.connections, connectionConflict: input.connectionConflict, usableConnectionId: input.usableConnectionId,
-        manageableConnectionIds: input.manageableConnectionIds, connectionReconciliationRequired: input.connectionReconciliationRequired,
-        assetReadAccount: input.assetReadAccount, activeAccount: input.activeAccount, boundary: REVIEW_BOUNDARY, receipt: input.receipt,
+        reviewTarget: input.reviewTarget, nextStep: input.nextStep,
+        walletName: input.connection?.connectionId === input.reviewTarget?.connectionId ? input.connection?.walletName : undefined,
+        boundary: REVIEW_BOUNDARY, receipt: input.receipt,
         walletObservation: input.walletObservation,
         acceptedWalletRunId: record.acceptedInput?.walletRunId,
         ...(readAfter === undefined ? {} : { nextStateReadAfterMs: readAfter }),
@@ -153,7 +144,7 @@ export function projectReviewView(input) {
             status: boundReview?.status ?? session.status, account: boundReview?.account ?? session.account,
             ...(!request && !session.plans[0]?.reviewModel && input.busyForAccount ? { accountRequestPending: true } : {}),
             preparing: !boundReview && !!session.preparationId,
-            error: !boundReview ? [input.preparationIssue && `Current account selection: ${input.preparationIssue}`,
+            error: !boundReview ? [input.preparationIssue && `Review target: ${input.preparationIssue}`,
                 session.preparationError && `Earlier review message: “${session.preparationError}”`].filter(Boolean).join("\n\n") || undefined : undefined,
             state: displayedReview },
         request, observationStopped: authority ? authority.observation_stopped === 1 : undefined });

package/dist/mcp/activeAccountResponse.js

@@ -1,8 +1,10 @@
+import { walletChainSchema } from "../core/session/chainAccounts.js";
 import { z } from "zod";
 export const activeAccountResponseSchema = z.discriminatedUnion("status", [
     z.object({
         status: z.literal("set"),
         account: z.string(),
+        chainId: walletChainSchema,
         source: z.literal("wallet_connection"),
         setAt: z.string(),
         boundary: z.literal("read_context_only_not_signing_authorization")
@@ -16,6 +18,7 @@ export function activeAccountResponse(active) {
         ? {
             status: "set",
             account: active.address,
+            chainId: active.chainId,
             source: active.source,
             setAt: active.setAt,
             boundary: "read_context_only_not_signing_authorization"

package/dist/mcp/responseGuidance.js

@@ -1,13 +1,12 @@
 import { EXTERNAL_PROPOSAL_SETTLEMENT_TOKEN_SELECTION_UNSUPPORTED_CLAIM_ID } from "../core/proposal/types.js";
 import { TOOL_NAMES } from "./toolNames.js";
-export function interactionStatusUserAnswerUse(hasWalletObservation = false, hasConnectionConflict = false, reconciliationRequired = false) {
+export function interactionStatusUserAnswerUse(hasWalletObservation = false, reconciliationRequired = false) {
     return {
         canAnswer: [
             "stored_active_account_read_context",
             "wallet_connections_when_wallet_availability_is_available",
             "connection_qualified_default_asset_account",
             "pending_local_wallet_connection_interactions",
-            ...(hasConnectionConflict ? ["multiple_saved_connections_require_user_targeted_disconnection"] : []),
             ...(reconciliationRequired ? ["unrecorded_service_connection_requires_wallet_removal_and_confirmed_absence"] : []),
             "pending_local_review_interactions",
             "wallet_operation_availability_separate_from_stored_transaction_facts"
@@ -25,11 +24,10 @@ export function interactionStatusUserAnswerUse(hasWalletObservation = false, has
             "complete_wallet_history",
             "profit_or_pnl"
         ],
-        preconditionFields: ["walletAvailability", "assetReadAccount", ...(hasConnectionConflict ? ["connectionConflict"] : []),
+        preconditionFields: ["walletAvailability", "assetReadAccount",
             ...(reconciliationRequired ? ["connectionReconciliationRequired"] : [])],
-        answerFields: ["activeAccount", "connections", "assetReadAccount", "pendingWalletConnections", "pendingReviewSessions", "walletAvailability",
-            ...(hasConnectionConflict ? ["connectionConflict"] : []),
-            "manageableConnectionIds", ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []),
+        answerFields: ["activeAccount", "requestedChains", "connection", "assetReadAccount", "pendingWalletConnections", "pendingReviewSessions", "walletAvailability",
+            "canDisconnect", ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []),
             ...(hasWalletObservation ? ["walletObservation"] : [])],
         diagnosticOnlyFields: [
             "pendingWalletConnections.truncated",
@@ -69,7 +67,7 @@ export function executionResultUserAnswerUse(fields = {}) {
             "profit_or_pnl"
         ],
         answerFields: [
-            "walletAvailability", "progress", ...(fields.hasConnectionConflict ? ["connectionConflict"] : []),
+            "walletAvailability", "progress",
             ...(fields.reconciliationRequired ? ["connectionReconciliationRequired"] : []), ...(hasWaitOutcome ? ["waitOutcome"] : []),
             "reviewSessionId",
             "status",
@@ -95,7 +93,7 @@ export function executionResultUserAnswerUse(fields = {}) {
         }
     };
 }
-export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle = false, hasHumanReadableReview = false, hasSimulation = false, hasConnectionConflict = false, reconciliationRequired = false) {
+export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle = false, hasHumanReadableReview = false, hasSimulation = false, reconciliationRequired = false) {
     return {
         canAnswer: [
             "current_local_review_session_status",
@@ -119,7 +117,7 @@ export function reviewStatusUserAnswerUse(hasReviewState, hasAdapterLifecycle =
             "profit_or_pnl"
         ],
         answerFields: [
-            "walletAvailability", "progress", ...(hasConnectionConflict ? ["connectionConflict"] : []),
+            "walletAvailability", "progress",
             ...(reconciliationRequired ? ["connectionReconciliationRequired"] : []), "reviewSessionId",
             "status",
             "pollingStatus",

package/dist/mcp/serverInfo.js

@@ -44,14 +44,14 @@ export const EVIDENCE_POLICY = {
     ]
 };
 export const SERVER_INSTRUCTIONS = [
-    "Sui MCP is a mainnet-only Sui DeFi intent evidence toolkit. Ordinary MCP tools return evidence or internal cards, never signing authority, bytes or signatures. Only user card selection and wallet approval authorize the backend WalletConnect flow: verify reviewed digest and signer, submit once, then read chain effects. Request status is separate from chain success/failure; uncertain results are read by digest, never resubmitted.",
-    "External proposals are untrusted facts; plans[].reviewModel is review context, not transaction material, route/settlement choice, signing/readiness, or execution readiness.",
-    "PTB graphs are diagnostics only; not transaction input, wallet authorization, signing/readiness, execution readiness, route quality, or safety.",
+    "Sui MCP is a mainnet-only Sui DeFi intent evidence toolkit. Ordinary MCP tools return evidence or internal cards, never signing authority, bytes or signatures. Only user card input and wallet approval authorize WalletConnect: verify reviewed digest and signer, submit once, then read chain effects. Request status is separate from chain success/failure; uncertain results are read by digest, never resubmitted.",
+    "External proposals are untrusted: plans[].reviewModel is non-signable context, not transaction material, route/settlement choice or execution readiness.",
+    "PTB graphs are diagnostics, not transaction input, authorization, readiness, route quality or safety.",
     "Use response-local fields: userAnswerUse.answerFields/preconditionFields/conclusionRuleFields/cannotAnswer/diagnosticOnlyFields/followUp, pollingHint, and quantitySemantics.",
-    "For USD-denominated payment coverage, balance total, or shortfall questions, call read_get_server_status, then read_list_settlement_asset_groups, then read_preview_intent_evidence. Use toolAvailability.requiredToolsAvailable and responseSummary.doNotCallQuoteToolsForThisQuestion; do not call wallet inventory or quote tools unless user asks a separate inventory or conversion question. For parity, use read_summarize_settlement_asset_group_parity. If toolAvailability cannot be used, say the current MCP server build cannot support the answer.",
-    "The active account context is read-only, not login, custody or signing permission. Implicit asset reads require session_get_interaction_status.assetReadAccount: available. Otherwise ask for an address only if the tool accepts account; connected-only tools require connection/account selection or wallet recovery.",
-    "Unsupported: other chains, autonomous trading, alerts, investment advice, arbitrary Move/package calls, P&L/tax.",
-    "One wallet connection at a time; docs: suimcp://docs/agent-behavior, suimcp://docs/mcp-tools."
+    "USD coverage/total/shortfall: read_get_server_status, then read_list_settlement_asset_groups, then read_preview_intent_evidence. Follow toolAvailability.requiredToolsAvailable and responseSummary.doNotCallQuoteToolsForThisQuestion. Inventory/quotes require a separate user request. Parity: read_summarize_settlement_asset_group_parity. Missing toolAvailability means this build cannot answer.",
+    "The active account context is read-only, not login, custody or signing permission. Implicit asset reads require session_get_interaction_status.assetReadAccount: available. Otherwise ask for account only if supported; connected-only reads need a saved address and usable connection. Settings Clear preserves connection and transaction authority.",
+    "Unsupported: other-chain financial actions, autonomous trading, alerts, investment advice, arbitrary Move/package calls, P&L/tax.",
+    "One connection fixes one address per approved chain: Sui/Ethereum/Solana. Wallet/address/scope changes require disconnect/reconnect. Finance is Sui-only. Connect/Disconnect cards end with address-free results and no actions. Docs: suimcp://docs/agent-behavior, suimcp://docs/mcp-tools."
 ].join("\n");
 export const IMPLEMENTED_TOOLS = [
     TOOL_NAMES.uiOpenAccount, TOOL_NAMES.uiOpenReceipt, TOOL_NAMES.uiOpenChart,
@@ -88,6 +88,7 @@ export const IMPLEMENTED_TOOLS = [
     TOOL_NAMES.actionCreateProposalReview,
     TOOL_NAMES.accountGetActiveAccount,
     TOOL_NAMES.sessionOpenWalletConnectionCard,
+    TOOL_NAMES.sessionOpenWalletDisconnectionCard,
     TOOL_NAMES.sessionGetWalletConnectionCard,
     TOOL_NAMES.sessionWaitWalletConnectionCard,
     TOOL_NAMES.sessionOpenReviewManagement,
@@ -114,7 +115,7 @@ export function toolAvailability(requiredTools) {
     };
 }
 export const SERVER_LIMITATIONS = [
-    "Current asset reads without a user-provided address require a selected account with a usable current wallet connection. session_get_interaction_status.assetReadAccount reports whether that default is available. Only tools with an account input accept explicit addresses; DeepBook account inventory requires a connected selected account. Explicit-address coin balance reads are public-address snapshots and do not create active account context. Active account is read context only, not signing authorization, login, custody, or persistent permission.",
+    "Current asset reads without a user-provided address require the fixed Sui address with a usable current wallet connection. session_get_interaction_status.assetReadAccount reports whether that default is available. Only tools with an account input accept explicit addresses; DeepBook account inventory requires the current connected Sui address. Explicit-address coin balance reads are public-address snapshots and do not create active account context. Active account is read context only, not signing authorization, login, custody, or persistent permission.",
     "Review activity tools summarize local Sui MCP review evidence only. Sui activity tools use user-requested bounded GraphQL reads and store normalized transaction facts only for known wallet context; function activity scans are sent-transaction scans only. They are not background indexers, complete history, balance history, complete gas history, affected-object history, or P&L.",
     `read_get_account_asset_timeline reads stored local account activity facts and returns observed raw net-flow bars with scan coverage. It does not start scans, prove complete wallet history, provide held balances without balanceBars, compute USD value, P&L, tax, cost basis, route advice, transaction-building input, signing data, or signing readiness. Optional USDC references are token-denominated ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerCandleReferences} only, ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.usdcNotFiatUsdAndNotPeg}.`,
     "Sui activity transactionContext facts are transaction-level facts without transaction-wide balance-change aggregates, and they are answer fields only when the response returns them. requestedAccountTransactionFacts, requestedAccount, and requestedAccountEffect are the account-specific balance-change surfaces. Activity quantitySemantics marks balance amountRaw fields as raw integers that require verified decimals for display conversion. accountBalanceChangeInferencePolicy marks whether returned account balance rows can be used or transaction-level context must not be used for account amount inference. Gas raw fields use MIST, and returned gasCost display facts use @mysten/sui MIST_PER_SUI.",
@@ -122,10 +123,10 @@ export const SERVER_LIMITATIONS = [
     "High-risk read responses include userAnswerUse. Prefer userAnswerUse.preconditionFields before answering, userAnswerUse.answerFields for the answer path, userAnswerUse.conclusionRuleFields for conclusion limits, userAnswerUse.diagnosticOnlyFields for source or troubleshooting context, and userAnswerUse.followUp when a different tool and field are required. USD intent and parity responses also include toolAvailability as a precondition field for current server-build support.",
     "Intent evidence maps natural-language USD-denominated targets to pinned DeepBook SDK settlement asset groups and current wallet balance evidence. responseSummary.answerCompleteness names the answer class and required fields. Settlement-asset-only answers use responseSummary; selected-target evidence requires user selection provenance and also uses selectedTarget, candidateConversions, and requiredUserChoices when userAnswerUse.answerFields lists them. Direct pool quote evidence is returned and supported only when a quoted candidate exists. responseSummary.doNotUseForConclusion names quote results, outside-settlement-group assets, and route-dependent support as excluded from the conclusion. Intent evidence does not silently choose settlement assets, rank venues or routes, evaluate gas reserve, build transactions, or produce signing material.",
     "DeepBook quotes convert explicit raw or display source inputs through pinned token units and return scoped SDK simulation facts plus raw quote evidence. Their quantitySemantics says canUseForPaymentAnswer and canUseForShortfallAnswer are false, doNotCombineWithPaymentAnswer is true, requiredPaymentAnswerTool is read_preview_intent_evidence, and requiredPaymentAnswerField is responseSummary.",
-    "Action preparation returns internal Review cards. A current card with valid UI permission automatically prepares and renews verified conditions for one selected wallet/account; only the explicit Request wallet approval action can request a signature. Supported DeepBook account-bound swap review verifies stored transaction material, digest, ownership, quote/policy, human-readable facts, simulation and PTB evidence. Only a scoped app-only user action and wallet approval authorize the backend WalletConnect request; ordinary MCP calls never sign or submit. Transaction bytes and signatures never enter card/model results. The backend verifies returned transaction digest and signer, submits once, and independently reads chain effects. requestStatus is separate from chain execution success/failure: stopped, request_failed and outcome_unknown do not prove a chain failure. Lost replies are resolved by reading the same request/digest, never automatic resubmission. External proposals remain non-signable. Receipts do not establish execution guarantees, route quality, fiat value, P&L, tax, peg proof or best-price advice.",
+    "Action preparation returns internal Review cards. A current card with valid UI permission automatically prepares and renews verified conditions for its original fixed wallet/account; only the explicit Request wallet approval action can request a signature. Supported DeepBook account-bound swap review verifies stored transaction material, digest, ownership, quote/policy, human-readable facts, simulation and PTB evidence. Only a scoped app-only user action and wallet approval authorize the backend WalletConnect request; ordinary MCP calls never sign or submit. Transaction bytes and signatures never enter card/model results. The backend verifies returned transaction digest and signer, submits once, and independently reads chain effects. requestStatus is separate from chain execution success/failure: stopped, request_failed and outcome_unknown do not prove a chain failure. Lost replies are resolved by reading the same request/digest, never automatic resubmission. External proposals remain non-signable. Receipts do not establish execution guarantees, route quality, fiat value, P&L, tax, peg proof or best-price advice.",
     "read_list_deepbook_pools and read_list_deepbook_tokens return static SDK registry metadata, not live liquidity, live token discovery, or active pool state.",
     `DeepBook orderbook, mid-price, and quote outputs are ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.pinnedSdkSnapshots} at fetchedAt; treat them as stale if the user delays.`,
     `DeepBook USDC price history and price-at-time reads use ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerCandleData} for the requested official interval. They are external candle evidence only, not live quotes, historical mid prices, global market prices, fiat USD values, USDC/USD peg guarantees, route recommendations, transaction-building inputs, signing readiness, P&L, cost basis, user-account transaction history, or user-account balance history. Sui MCP does not independently recompute those candle values from chain history for the response.`,
     `ui_open_chart displays ${DEEPBOOK_SOURCE_OWNER_RUNTIME_WORDING.officialIndexerUsdcDenominatedCandles} in an internal read-only card. ui_open_account displays a public-address asset snapshot; ui_open_receipt displays the executed transaction graph when bound UI metadata is available, followed by on-chain facts and a Details slide. Card inputs end after backend admission, expiry or invalidation; chat navigation and frame recreation do not end valid unsubmitted input. Read the same DB state after a lost reply rather than resubmitting. Saved results do not authorize a new query or transaction. These cards are not live feeds, trading interfaces, route recommendations, fiat USD value, P&L, tax, cost basis, signing data, or signing readiness.`,
-    "Settings uses an internal card. MCP settings tools create the card or read current settings; only the user's scoped card confirmation applies local changes or restarts the connection service. Backup bytes stay in app-only file transfer. No external Settings URL exists."
+    "Settings uses an internal card. MCP settings tools create the card or read current settings; only the user's scoped card confirmation applies local changes or restarts the connection service. Backup bytes stay in app-only file transfer. Closed cards are immutable; another delivery requires a new backupDelivery card for the same retained snapshot, and operationStatus records current cleanup without repeating an effect. No external Settings URL exists."
 ];