@itpay/cli 2.1.34 → 2.1.41

package/README.md

@@ -4,7 +4,7 @@ The official V3 CLI and the single ItPay entry point for services, purchases, ac
 
 ## One Entry Point, Several Human Intents
 
-`itpay` is the only public CLI entry point, and `$itpay` is its user-facing Skill invocation. The Agent first distinguishes a new service request, previously purchased content, order history, or a refund. Seller workflows use the existing `itpay sell` entry point.
+`itpay` is the only public CLI entry point, and `$itpay` is its user-facing Skill invocation. The Agent first distinguishes a new service request, previously purchased content, order history, or a refund. Seller workflows will use the same entry point later and are not implemented yet.
 
 ```bash
 npm install -g @itpay/cli
@@ -25,7 +25,7 @@ Official Agent install prompt（可直接复制给 Agent）：
 Use a separate test prompt to set the exact official Dev Backend. Never put a
 Dev override in the public install prompt.
 
-The CLI defaults to the production Backend `https://app.itpay.ai`. Explicit sandbox runs may set `ITPAY_BACKEND_URL=https://sandbox.itpay.ai`; every other Backend URL is rejected before network or local state access.
+The CLI defaults to the production Backend `https://app.itpay.ai`. Explicit tests may set `ITPAY_BACKEND_URL=https://dev.itpay.ai`; every other Backend URL is rejected before network or local state access.
 
 ## Output Contract
 
@@ -54,7 +54,6 @@ Normative per-command contracts: [CLI Command Reference](docs/cli-reference/inde
 | `claude-code-cli` | `terminal` |
 | `workbuddy` | `plain-chat` |
 | `zcode` | `plain-chat` |
-| `doubao-work` | `plain-chat` |
 | `kimi-code` | `terminal` |
 | `openclaw` | 必须显式提供 |
 
@@ -68,7 +67,7 @@ The local installation keeps one Ed25519 private key and a separate registration
 - `services start/invoke/action/checkout/next`: generic Service Execution flow.
 - `cart add/show/remove/clear/next`, `buy`: canonical Cart and ordinary Checkout flow.
 - `checkout`: authoritative payment and fulfillment recovery.
-- `services read-result`: read saved railway query pages or human-granted protected content.
+- `services read-result`: read one human-granted protected result.
 - `order`, `orders`: exact order and account order views.
 - `vault list/access/read`: find and read previously purchased content after time-limited human authorization.
 - `refund create/list/get/watch/cancel`: Refund Owner flow.
@@ -91,12 +90,12 @@ itpay --agent-type <agent_type> services checkout <service_execution_id> --resum
 itpay checkout --id <checkout_id> --token <display_token> --json
 ```
 
-The local `~/.itpay-v3` directory stores one owner-only signing key, Backend-scoped Device registrations and Agent instances, idempotency operations, and recovery handles. Production uses `cart.json` / `operations.json`; sandbox uses `cart.sandbox.json` / `operations.sandbox.json`. Backend state remains authoritative. Do not delete or rotate this identity to recover quota.
+The local `~/.itpay-v3` directory stores one owner-only signing key, Backend-scoped Device registrations and Agent instances, idempotency operations, and recovery handles. Production uses `cart.json` / `operations.json`; dev uses `cart.dev.json` / `operations.dev.json`. Backend state remains authoritative. Do not delete or rotate this identity to recover quota.
 
 ## Environment
 
 - `ITPAY_AGENT_TYPE`: stable alternative to global `--agent-type`.
-- `ITPAY_BACKEND_URL`: optional sandbox override; only the exact official URL `https://sandbox.itpay.ai` is accepted. Unset it for production.
+- `ITPAY_BACKEND_URL`: optional test override; only the exact official URL `https://dev.itpay.ai` is accepted. Unset it for production.
 - `ITPAY_BEARER_TOKEN`: optional account-scoped browser session for legacy account reads. Local Agents normally use signed Device Authority plus the time-limited human authorization returned by `vault access`.
 - `ITPAY_CART_SESSION_PATH`: local recovery-state path override.
 - `ITPAY_CURRENCY`: ordinary Cart currency, default `CNY`.
@@ -128,9 +127,3 @@ Source boundaries:
 - `src/state`: local Device Authority, idempotency journal, and recovery handles.
 - `docs/cli-reference`: normative command contracts.
 - `docs/agent/buyer`: packaged progressive workflow guidance.
-
-### Run a published service
-
-Use `itpay services run <service_id> --input-json ./input.json --json` for a published workflow. The input file must contain a JSON object matching the service input schema. With no input file, the CLI reports required fields and a command to continue the same execution.
-
-Use `itpay services run <service_id> --execution <execution_id> --json` to resume. At payment, the CLI uses the existing Checkout QR/card handoff. The backend continues after verified payment even if the CLI exits. `--timeout <seconds>` controls initial status polling (default 120, maximum 600). Use existing order/refund commands for refund requests; an application is not a successful refund until its final status confirms success.

package/dist/src/client/backend.js

@@ -5,19 +5,6 @@ export class BackendClient {
     constructor(http) {
         this.http = http;
     }
-    get localSimulation() { return this.http.localSimulation; }
-    // Called only through the fixed Sell operation contract, never arbitrary Agent URLs.
-    sellRequest(request) {
-        if (!request.path.startsWith("/v1/seller/organizations") && !request.path.startsWith("/v1/library/"))
-            throw new Error("Invalid Sell route");
-        return this.http.request(request.path, { method: request.method, ...(request.body !== undefined ? { body: request.body } : {}) });
-    }
-    agentAccountStatus() {
-        return this.http.get('/v1/agent-device-account-bindings');
-    }
-    bindAgentAccount(input) {
-        return this.http.post('/v1/agent-device-account-bindings', input);
-    }
     readyz() {
         return this.http.get("/v1/readyz");
     }
@@ -121,15 +108,6 @@ export class BackendClient {
     startServiceExecution(input) {
         return this.http.post("/v1/service-executions", input);
     }
-    advanceServiceExecution(id, input, idempotencyKey) {
-        return this.http.post(`/v1/service-executions/${encodeURIComponent(id)}/advance`, { input, idempotency_key: idempotencyKey });
-    }
-    getServiceExecutionResultItemPage(serviceExecutionID, resultItemID, offset, limit, view) {
-        const qs = new URLSearchParams({ offset: String(offset), limit: String(limit) });
-        if (view)
-            qs.set("view", view);
-        return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/result-items/${encodeURIComponent(resultItemID)}?${qs}`);
-    }
     invokeServiceCapability(serviceExecutionID, capabilityID, input) {
         return this.http.post(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/capabilities/${encodeURIComponent(capabilityID)}/invoke`, input, { replaySafe: Boolean(input.idempotency_key) });
     }
@@ -142,9 +120,8 @@ export class BackendClient {
     prepareServiceQuote(serviceExecutionID, input) {
         return this.http.post(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/quotes`, input, { replaySafe: true });
     }
-    getServiceExecution(serviceExecutionID, opts = {}) {
-        const query = opts.sinceSnapshot ? `?since_snapshot=${encodeURIComponent(opts.sinceSnapshot)}` : "";
-        return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}${query}`);
+    getServiceExecution(serviceExecutionID) {
+        return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}`);
     }
     listServiceExecutions(limit = 50) {
         return this.http.get(`/v1/service-executions?limit=${limit}`);
@@ -159,14 +136,6 @@ export class BackendClient {
     getGrantedServiceResult(serviceExecutionID) {
         return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/granted-result`);
     }
-    getRailPlanningCatalog(serviceExecutionID, snapshotID) {
-        const query = snapshotID ? `?snapshot=${encodeURIComponent(snapshotID)}` : "";
-        return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/rail-planning/catalog${query}`);
-    }
-    getRailJourneyDetail(serviceExecutionID, journeyID, snapshotID) {
-        const query = snapshotID ? `?snapshot=${encodeURIComponent(snapshotID)}` : "";
-        return this.http.get(`/v1/service-executions/${encodeURIComponent(serviceExecutionID)}/rail-planning/journeys/${encodeURIComponent(journeyID)}${query}`);
-    }
 }
 // --- SSE streaming helper ---
 async function streamSSE(url, onEvent, signal) {

package/dist/src/client/http.js

@@ -14,7 +14,6 @@ export class HttpError extends Error {
     }
 }
 export class HttpClient {
-    localSimulation = false;
     static MAX_TRANSPORT_RETRIES = 2;
     baseURL;
     fetchImpl;
@@ -71,7 +70,6 @@ export class HttpClient {
                     ...(options.signal ? { signal: options.signal } : {}),
                 });
                 text = await response.text();
-                this.localSimulation = response.headers.get("X-ItPay-Environment") === "local_simulation";
             }
             catch (error) {
                 if (options.signal?.aborted)

package/dist/src/commands/buy.js

@@ -106,7 +106,6 @@ export async function runBuy(backend, config, options) {
     }
     // --- Build render plan (after payment if --pay) ---
     const planInput = {
-        localSimulation: backend.localSimulation,
         host: options.host,
         checkoutID,
         checkoutURL,
@@ -136,7 +135,7 @@ export async function runBuy(backend, config, options) {
         });
     }
     // --- Output ---
-    if (options.jsonOutput || platformKeyForHost(options.host) === "plain_chat") {
+    if (options.jsonOutput) {
         const envelope = buildBuyEnvelope({
             cart,
             checkoutID,
@@ -149,7 +148,7 @@ export async function runBuy(backend, config, options) {
             ...(options.agentType ? { agentType: options.agentType } : {}),
             ...(options.target ? { target: options.target } : {}),
         });
-        writeCommandEnvelope(envelope, { jsonOutput: Boolean(options.jsonOutput), ...(options.output ? { output: options.output } : {}), ...(options.agentType ? { agentType: options.agentType } : {}) });
+        writeCommandEnvelope(envelope, { jsonOutput: true, ...(options.output ? { output: options.output } : {}) });
         return {
             kind: "checkout_rendered",
             plan,
@@ -204,7 +203,6 @@ function buildBuyEnvelope(input) {
     const presentationHandoff = buildCheckoutHandoff({
         platform,
         url: input.plan.linkOnlyURL ?? input.checkoutURL,
-        mobileUrl: input.checkoutURL,
         amount,
         plan: input.plan,
         ...(input.agentType ? { agentType: input.agentType } : {}),
@@ -220,7 +218,7 @@ function buildBuyEnvelope(input) {
         result,
         handoff: presentationHandoff.handoff,
         instruction: presentationHandoff.instruction,
-        next: { command: input.plan.afterActionCommand ?? `itpay checkout --id ${input.checkoutID} --token ${input.displayToken} --json`, reason: "仅用户完成付款或要求查询时，读取同一笔Checkout权威状态" },
+        next: { command: input.plan.afterActionCommand ?? `itpay checkout --id ${input.checkoutID} --token ${input.displayToken} --json`, reason: "稍后查询同一笔 Checkout 状态" },
         recovery: [],
     };
 }
@@ -247,7 +245,7 @@ async function waitForPaymentSSE(backend, checkoutID, displayToken, timeoutSec)
 }
 // --- checkout QR plan ---
 export function buildCheckoutQRPlan(input) {
-    const summary = input.localSimulation ? "在本机打开模拟付款入口；铁路与地图查询真实，授权、通知和交易模拟，不会扣款。" : `Scan the QR or open ${input.checkoutURL} to start the human checkout flow.`;
+    const summary = `Scan the QR or open ${input.checkoutURL} to start the human checkout flow.`;
     const isPayment = input.paymentIntentID != null;
     const afterCommand = qualifyItPayCommand(`itpay checkout --id ${input.checkoutID} --token ${input.displayToken}${input.locale === "en" ? " --locale en" : ""} --json`, input.agentType);
     const platform = {
@@ -266,7 +264,6 @@ export function buildCheckoutQRPlan(input) {
     };
     const plan = {
         kind: isPayment ? "payment_qr" : "checkout_qr",
-        ...(input.localSimulation ? { localSimulation: true } : {}),
         host: input.host,
         summary,
         url: input.qrPayload,

package/dist/src/commands/cart.js

@@ -21,7 +21,7 @@ export function runCartAdd(session, options) {
             offer_id: item.offerID,
             quantity: item.quantity,
         },
-        instruction: "仅写入本地兼容草稿，未验证目录、价格或服务合同；不要把它当作 服务端购物车。",
+        instruction: "仅写入本地兼容草稿，未验证目录、价格或服务合同；不要把它当作 canonical Cart。",
         next: { command: "itpay cart show --local", reason: "检查本地草稿" },
         recovery: [],
     };
@@ -74,10 +74,10 @@ export async function runCartAddServer(options) {
         },
         instruction: serviceExecutionID
             ? "服务型项目已创建 Service Execution；先读取其当前步骤，不要直接进入普通 buy。"
-            : "普通项目已加入 服务端购物车；先检查购物车，再创建 Checkout。",
+            : "普通项目已加入 canonical Cart；先检查购物车，再创建 Checkout。",
         next: serviceExecutionID
             ? { command: `itpay services next ${serviceExecutionID} --json`, reason: "读取服务执行的当前步骤" }
-            : { command: "itpay cart next --json", reason: "检查 服务端购物车" },
+            : { command: "itpay cart next --json", reason: "检查 canonical Cart" },
         recovery: [],
     };
     writeCommandEnvelope(envelope, {
@@ -121,7 +121,7 @@ export async function runCartAddQuoteServer(options) {
             total: formatMoney(cart.amount_minor, cart.currency),
         },
         instruction: "付费服务报价已加入同一 Cart；每个项目仍保持独立 Execution 和交付。",
-        next: { command: `itpay buy --cart ${cart.cart_id} --json`, reason: "仅已有购买授权且项目齐全时创建一次合并付款" },
+        next: { command: `itpay buy --cart ${cart.cart_id} --json`, reason: "确认项目齐全后创建一次合并付款" },
         recovery: [{ command: "itpay cart show --json", reason: "检查当前合并 Cart" }],
     };
     writeCommandEnvelope(envelope, {
@@ -144,7 +144,7 @@ export function runCartRemove(session, options) {
             catalog_variant_id: options.catalogVariantID,
             offer_id: options.offerID,
         },
-        instruction: "本地兼容草稿已更新；这不代表任何 服务端购物车 或 Service Execution 已变更。",
+        instruction: "本地兼容草稿已更新；这不代表任何 canonical Cart 或 Service Execution 已变更。",
         next: { command: "itpay cart show --local --json", reason: "检查剩余本地草稿" },
         recovery: [],
     }, {
@@ -176,7 +176,7 @@ export async function runCartRemoveServer(backend, session, cartItemID, options
             cart_item_id: lineID,
             remaining_item_count: cart.items.length,
         },
-        instruction: "服务端购物车 已更新；被删除的最后一个 服务项目 对应执行会由服务端同时取消。",
+        instruction: "canonical Cart 已更新；被删除的最后一个 service-backed line 对应执行会由服务端一致性事务取消。",
         next: { command: "itpay cart next --json", reason: "检查剩余内容" },
         recovery: [],
     };
@@ -198,10 +198,10 @@ export function runCartShow(session, options = {}) {
         status: items.length > 0 ? "shown_local" : "local_empty",
         result: { currency: snap.currency, items },
         instruction: items.length > 0
-            ? "这是未验证的本地兼容草稿，只能用于明确的普通商品流程；不要把它当作 服务端购物车。"
+            ? "这是未验证的本地兼容草稿，只能用于明确的普通商品流程；不要把它当作 canonical Cart。"
             : "本地兼容草稿为空；从已发布目录重新选择项目。",
         next: items.length > 0
-            ? { command: "itpay buy --json", reason: "将普通本地草稿提交为 服务端购物车" }
+            ? { command: "itpay buy --json", reason: "将普通本地草稿提交为 canonical Cart" }
             : { command: "itpay catalog list --json", reason: "读取已发布目录" },
         recovery: [],
     };
@@ -215,7 +215,7 @@ export async function runCartShowServer(backend, session, options = {}) {
         writeCommandEnvelope({
             status: "cart_handle_missing",
             result: {},
-            instruction: "本地没有 服务端购物车 句柄；不要把本地草稿默认为服务端 Cart。",
+            instruction: "本地没有 canonical Cart 句柄；不要把本地草稿默认为服务端 Cart。",
             next: { command: "itpay catalog list --json", reason: "读取已发布目录" },
             recovery: [{ command: "itpay cart show --local --json", reason: "仅在明确需要时检查本地兼容草稿" }],
         }, {
@@ -241,7 +241,7 @@ export async function runCartShowServer(backend, session, options = {}) {
         },
         instruction: items.length > 0
             ? "使用 line 或 execution 句柄继续；不要使用内部 quote lock ID。"
-            : "服务端购物车 当前为空；从已发布目录选择项目。",
+            : "canonical Cart 当前为空；从已发布目录选择项目。",
         next: items.length > 0
             ? { command: "itpay cart next --json", reason: "取得当前首选动作" }
             : { command: "itpay catalog list --json", reason: "读取已发布目录" },
@@ -278,7 +278,7 @@ export async function runCartAbandonServer(backend, session, options = {}) {
         writeCommandEnvelope({
             status: "cart_handle_missing",
             result: {},
-            instruction: "本地没有 服务端购物车 句柄；未修改任何 Backend 或本地资源。",
+            instruction: "本地没有 canonical Cart 句柄；未修改任何 Backend 或本地资源。",
             next: { command: "itpay next --json", reason: "检查其他可恢复句柄" },
             recovery: [{ command: "itpay cart clear --local --json", reason: "仅在明确放弃本地草稿和句柄时执行" }],
         }, {
@@ -292,7 +292,7 @@ export async function runCartAbandonServer(backend, session, options = {}) {
     const envelope = {
         status: "abandoned",
         result: { cart_id: cart.cart_id, server_abandoned: true },
-        instruction: "服务端购物车 已放弃；服务端已清空有效项目，并取消关联的未付款服务执行。",
+        instruction: "canonical Cart 已放弃；Backend 已在同一事务中软删除 active lines，并取消其未付款 Service Execution。",
         next: { command: "itpay catalog list --json", reason: "仅在用户提出新需求时重新选择" },
         recovery: [],
     };
@@ -308,7 +308,7 @@ export async function runCartNext(backend, session, options = {}) {
         writeCartNextEnvelope({
             status: "cart_handle_missing",
             result: {},
-            instruction: "本地没有 服务端购物车 句柄；先恢复已有资源，不要创建重复 Cart。",
+            instruction: "本地没有 canonical Cart 句柄；先恢复已有资源，不要创建重复 Cart。",
             next: { command: "itpay next --json", reason: "检查其他可恢复句柄" },
             recovery: [{ command: "itpay services list --json", reason: "从服务端恢复当前设备的执行" }],
         }, options);
@@ -325,7 +325,7 @@ export async function runCartNext(backend, session, options = {}) {
                 cart_status: cart.status,
                 service_execution_id: unquotedServiceLine.service_execution_id,
             },
-            instruction: "该 Cart 包含 服务项目；继续 Service Execution，不要从 Cart 猜 capability。",
+            instruction: "该 Cart 包含 service-backed line；继续 Service Execution，不要从 Cart 猜 capability。",
             next: {
                 command: `itpay services next ${unquotedServiceLine.service_execution_id} --json`,
                 reason: "读取服务端最新执行状态",
@@ -355,7 +355,7 @@ export async function runCartNext(backend, session, options = {}) {
             instruction: cart.items.some((item) => item.service_quote_lock_id)
                 ? "服务报价已锁定输入和价格；确认项目齐全后使用同一 Cart 创建一次 Checkout。"
                 : "该 Cart 是普通购买流程；使用同一 Cart 创建 Checkout，不要重复添加商品。",
-            next: { command: `itpay buy --cart ${cart.cart_id} --json`, reason: "仅已有购买授权时继续服务端购物车结算" },
+            next: { command: `itpay buy --cart ${cart.cart_id} --json`, reason: "继续 canonical Cart 结算" },
             recovery: [],
         };
     }

package/dist/src/commands/catalog.js

@@ -9,11 +9,14 @@ export async function runCatalogList(backend, options = {}) {
         status: empty ? "catalog_empty" : "listed",
         result: { catalog_version: manifest.version, services },
         instruction: empty
-            ? "当前没有已发布服务；本次目录读取结束，不猜测服务或自动重试。"
+            ? "当前没有已发布服务；稍后重试，不要猜测 service_id。"
             : "向用户解释主服务、辅助步骤和价格；得到用户意图后再启动对应 service_id。",
-        next: services.length === 1 && firstServiceID
-            ? { command: `itpay services start ${firstServiceID}${jsonFlag}`, reason: "仅当当前服务符合用户请求时读取输入合同；不表示购买同意" }
-            : null,
+        next: empty
+            ? { command: `itpay catalog list${jsonFlag}`, reason: "稍后重新读取已发布目录" }
+            : {
+                command: `itpay services start ${services.length === 1 && firstServiceID ? firstServiceID : "<service_id>"}${jsonFlag}`,
+                reason: "启动用户选择的服务",
+            },
         recovery: [],
     }, {
         ...options,
@@ -22,13 +25,10 @@ export async function runCatalogList(backend, options = {}) {
 }
 function summarizeService(item) {
     const flow = item.service_flow;
-    const offer = item.variants?.[0];
     return {
         service_id: item.service_id ?? null,
-        ...(item.service_id ? { entry: `itpay services start ${item.service_id} --json` } : {}),
         title: item.title,
         description: item.description ?? "",
-        ...(item.service_id?.startsWith("itpay-rail-") ? { guide: "itpay docs show rail-booking" } : {}),
         ...(flow ? {
             discovery: {
                 title: flow.discovery.title,
@@ -43,12 +43,6 @@ function summarizeService(item) {
                 description: flow.primary_service.description,
                 price: formatProductMoney(flow.primary_service.amount_minor, flow.primary_service.currency),
             },
-        } : offer ? {
-            primary_offer: {
-                title: offer.title || item.title,
-                description: item.description ?? "",
-                price: formatProductMoney(offer.amount_minor, offer.currency),
-            },
         } : {}),
     };
 }
@@ -57,10 +51,6 @@ function catalogPlainLines(version, services) {
     for (const service of services) {
         lines.push(`service: ${String(service.title)}`);
         lines.push(`  service_id: ${String(service.service_id ?? "unavailable")}`);
-        if (service.entry)
-            lines.push(`  entry: ${String(service.entry)}`);
-        if (service.guide)
-            lines.push(`  entry: ${String(service.guide)}`);
         if (service.description)
             lines.push(`  description: ${String(service.description)}`);
         const discovery = service.discovery;

package/dist/src/commands/checkout.js

@@ -5,40 +5,11 @@ import { buildAgentChatHandoff } from "../render/markdown.js";
 import { platformKeyForHost } from "../render/plan.js";
 import { renderTerminalQR } from "../render/qr.js";
 import { localizeCardURL, normalizeCardLocale } from "../render/locale.js";
-import { openInSystemBrowser } from "../render/browser.js";
-import { hostCapabilities, normalizeViewer } from "../state/client_context.js";
 import { DEFAULT_BASE_URL } from "../state/config.js";
 import { buildCheckoutQRPlan } from "./buy.js";
 import { buildCheckoutHandoff, shouldPrepareLocalCheckoutImage } from "./checkout_handoff.js";
-import { CommandContractError, plainValueLines, writeCommandEnvelope } from "./guidance.js";
-import { resolvePresentation, resolveRelay } from "./presentation.js";
+import { writeCommandEnvelope } from "./guidance.js";
 export async function runCheckoutPresentation(backend, options) {
-    const present = options.present;
-    if (present !== undefined && !["auto", "browser", "image", "link", "none"].includes(present)) {
-        throw new CommandContractError("present_invalid", `--present must be one of auto|browser|image|link|none`, "使用支持的展示方式；未知参数已被拒绝。", []);
-    }
-    const relayRequested = Boolean(options.relayOption || options.confirmRelay || options.requestKey || options.relayStatus);
-    if (relayRequested && options.present && options.present !== "none") {
-        throw new CommandContractError("present_relay_conflict", "--present and --relay-* options are mutually exclusive", "展示和消息转发二选一；不要在同一次调用中同时开页面和发消息。", []);
-    }
-    if (options.noOpen && options.present === "browser") {
-        throw new CommandContractError("present_conflict", "--present browser conflicts with --no-open", "--no-open 与浏览器展示冲突；改用 --present link 或 image。", []);
-    }
-    if (options.relayStatus) {
-        // Read-only relay status. The backend exposes no relay routes yet, so the
-        // honest answer is unavailable — never a resend, never a guessed state.
-        writeCommandEnvelope({
-            status: "relay_unavailable",
-            result: { relay_id: options.relayStatus },
-            instruction: "当前 Backend 未提供消息转发状态查询；不要重发。读取原订单/Checkout 状态核对。",
-            next: { command: `itpay checkout --id ${options.checkoutID} --token ${options.displayToken} --json`, reason: "读取原 Checkout 当前状态" },
-            recovery: [],
-        }, {
-            ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
-            ...(options.output ? { output: options.output } : {}),
-        });
-        return;
-    }
     const locale = normalizeCardLocale(options.locale);
     const presentation = await backend.getCheckoutPresentation(options.checkoutID, options.displayToken, locale === "en" ? locale : undefined);
     const host = options.host ?? "terminal";
@@ -51,13 +22,12 @@ export async function runCheckoutPresentation(backend, options) {
         });
         return;
     }
-    const checkoutURL = savedCheckoutURLOrFallback(options.savedCheckoutURL, options.checkoutID, options.displayToken, checkoutPageURL(options.baseURL, options.checkoutID, options.displayToken));
+    const checkoutURL = checkoutPageURL(options.baseURL, options.checkoutID, options.displayToken);
     const cardURL = localizeCardURL(absolutePublicURL(options.baseURL, presentation.card_url ?? checkoutCardURL(options.baseURL, options.checkoutID, options.displayToken)), locale);
     const qrPNGURL = absolutePublicURL(options.baseURL, presentation.card_png_url ?? presentation.qr_png_url ?? checkoutCardPNGURL(options.baseURL, options.checkoutID, options.displayToken));
     const localizedPNGURL = localizeCardURL(qrPNGURL, locale);
     const nextCommand = `itpay checkout --id ${options.checkoutID} --token ${options.displayToken}${locale === "en" ? " --locale en" : ""} --json`;
     const plan = buildCheckoutQRPlan({
-        localSimulation: backend.localSimulation,
         host,
         checkoutID: options.checkoutID,
         checkoutURL,
@@ -82,64 +52,6 @@ export async function runCheckoutPresentation(backend, options) {
         });
     }
     const envelope = pendingCheckoutEnvelope(presentation, checkoutURL, plan, nextCommand, options.agentType, options.target);
-    // W5: deterministic presentation plan — business state first, then declared
-    // capabilities. `present` is the explicit display request; without it (or
-    // under --json alone) nothing opens.
-    // An explicit --viewer (including "unknown") wins over the host default.
-    const viewer = options.viewer ? normalizeViewer(options.viewer) : (host === "terminal" ? "desktop" : "unknown");
-    const locality = ["terminal", "codex", "claude-code"].includes(host) ? "same_device" : "unknown";
-    const decision = resolvePresentation({
-        business: {
-            commerce_policy: "allowed",
-            payment_state: "unpaid",
-            quote_valid: presentation.rail_quote?.expires_at
-                ? Date.parse(presentation.rail_quote.expires_at) > Date.now()
-                : true,
-            amount_minor: presentation.checkout.amount_minor,
-        },
-        viewer,
-        executor_locality: locality,
-        capabilities: hostCapabilities(host),
-        ...(explicitChoiceFor(options.present) ? { explicit_choice: explicitChoiceFor(options.present) } : {}),
-    });
-    const presentationResult = {
-        recommended: decision.recommended,
-        alternatives: decision.alternatives,
-        ...(decision.blocker ? { blocker: decision.blocker } : {}),
-    };
-    let dispatch = { status: "not_attempted" };
-    // Explicit --present browser may open even under --json (the flag IS the
-    // display request); --present auto under --json stays a plan and never opens.
-    const browserRequested = options.present === "browser"
-        || (options.present === "auto" && !options.jsonOutput && !options.noOpen && decision.recommended === "open_system_browser");
-    if (browserRequested && !options.noOpen && process.env.ITPAY_NO_BROWSER !== "1") {
-        const target = decision.recommended === "open_embedded_browser" ? decision.recommended : "open_system_browser";
-        dispatch = await openInSystemBrowser(checkoutURL, options.baseURL);
-        presentationResult.dispatched = { route: target, observation: dispatch.status };
-        // Dispatch proves the request was accepted — nothing about visibility.
-        if (dispatch.status === "dispatch_accepted") {
-            envelope.instruction += " 已发起在本机浏览器打开官方确认页；只有用户确认看到页面才视为已显示，没看到时改发链接。";
-        }
-        else {
-            envelope.instruction += " 浏览器打开未成功；按 handoff 链接展示，不要重复尝试同一方式。";
-        }
-    }
-    if (relayRequested) {
-        presentationResult.relay = resolveRelay({
-            ...(options.relayOption ? { relayOption: options.relayOption } : {}),
-            ...(options.confirmRelay ? { confirmRelay: options.confirmRelay } : {}),
-            ...(options.requestKey ? { requestKey: options.requestKey } : {}),
-            backendCapability: false,
-        });
-        envelope.instruction += " 消息转发当前不可用；不要声称已发送，改用现有官方入口展示。";
-    }
-    envelope.result = { ...envelope.result, presentation: presentationResult };
-    envelope.communication = {
-        schema_version: "itpay.communication.v1",
-        tell: decision.communication.tell,
-        wait_for: decision.communication.wait_for,
-        must_convey: decision.communication.must_convey,
-    };
     const plainResult = checkoutPlainResult(envelope.result);
     if (!options.jsonOutput && platformKeyForHost(host) === "terminal") {
         plainResult.push("qr:", await renderTerminalQR(checkoutURL, "terminal"));
@@ -150,21 +62,12 @@ export async function runCheckoutPresentation(backend, options) {
         plainResult,
     });
 }
-function explicitChoiceFor(present) {
-    switch (present) {
-        case "browser": return "open_system_browser";
-        case "link": return "show_link";
-        case "image": return "show_official_image";
-        default: return undefined;
-    }
-}
 function pendingCheckoutEnvelope(presentation, checkoutURL, plan, nextCommand, agentType, target) {
     const platform = platformKeyForHost(plan.host);
     const amount = formatMoney(presentation.checkout.amount_minor, presentation.checkout.currency);
     const presentationHandoff = buildCheckoutHandoff({
         platform,
         url: plan.linkOnlyURL ?? checkoutURL,
-        mobileUrl: checkoutURL,
         amount,
         plan,
         ...(agentType ? { agentType } : {}),
@@ -175,46 +78,16 @@ function pendingCheckoutEnvelope(presentation, checkoutURL, plan, nextCommand, a
             : {}),
         ...(platform === "markdown" ? { markdown: buildAgentChatHandoff(plan).markdown } : {}),
     });
-    const railQuote = presentation.rail_quote;
-    const railPassengersPending = presentation.checkout_details === "rail_passengers" && !presentation.rail_passengers_confirmed;
     return {
         status: "human_checkout_required",
         result: {
             checkout_id: presentation.checkout.checkout_id,
             payment: "pending",
             amount,
-            ...(railQuote ? { rail_quote: {
-                    passengers: railQuote.passengers,
-                    expires_at: railQuote.expires_at,
-                    legs: railQuote.legs.map((leg) => ({
-                        train_code: leg.train_code,
-                        travel_date: leg.travel_date,
-                        route: `${leg.from} → ${leg.to}`,
-                        time: `${leg.departure}–${leg.arrival}`,
-                        seat_name: leg.seat_name,
-                        ...(leg.seat_preferences?.length ? { seat_preferences: leg.seat_preferences } : {}),
-                        ...(leg.seat_request_planned ? {
-                            seat_request_planned: leg.seat_request_planned,
-                            auto_reason: leg.auto_reason ?? "none",
-                        } : {}),
-                    })),
-                } } : {}),
-            ...(railPassengersPending ? { rail_passengers_confirmed: false } : {}),
-            ...(presentation.payment_deadline_at ? { payment_deadline_at: presentation.payment_deadline_at } : {}),
-            ...(typeof presentation.payment_remaining_seconds === "number"
-                ? { payment_remaining_seconds: presentation.payment_remaining_seconds }
-                : {}),
-            ...(presentation.server_now ? { server_now: presentation.server_now } : {}),
-            ...(presentation.verified_sms_contact ? { verified_sms_contact: presentation.verified_sms_contact } : {}),
-            ...(presentation.account_phone_option?.masked_recipient
-                ? { account_phone_option: { masked_recipient: presentation.account_phone_option.masked_recipient } }
-                : {}),
         },
         handoff: presentationHandoff.handoff,
-        instruction: railPassengersPending
-            ? `${presentationHandoff.instruction} 请用户在受保护网页填写乘车人并确认报价；姓名、证件和手机号只在网页填写，不要贴到对话中。座位偏好仅为购票请求、购票时才提交给供应商且不保证满足；无法逐人提交的偏好将自动分配座位，以实际出票为准。`
-            : presentationHandoff.instruction,
-        next: { command: nextCommand, reason: "展示后停止；仅用户完成操作或要求核对时读取同一 Checkout" },
+        instruction: presentationHandoff.instruction,
+        next: { command: nextCommand, reason: "稍后只查询同一 Checkout" },
         recovery: [],
     };
 }
@@ -261,7 +134,7 @@ function checkoutNeedsHumanHandoff(status) {
     return !new Set(["payment_succeeded", "completed", "failed", "expired", "refunded"]).has(status);
 }
 function checkoutPlainResult(result) {
-    return plainValueLines(result);
+    return Object.entries(result).map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
 }
 function formatMoney(amountMinor, currency) {
     return `${(amountMinor / 100).toFixed(2)} ${currency}`;
@@ -270,20 +143,6 @@ function checkoutPageURL(baseURL, checkoutID, displayToken) {
     const root = publicRoot(baseURL);
     return `${root}/checkout/${encodeURIComponent(checkoutID)}?display_token=${encodeURIComponent(displayToken)}`;
 }
-function savedCheckoutURLOrFallback(savedURL, checkoutID, displayToken, fallback) {
-    if (!savedURL) {
-        return fallback;
-    }
-    try {
-        const parsed = new URL(savedURL);
-        const belongsToCheckout = parsed.pathname === `/checkout/${checkoutID}`;
-        const sameToken = parsed.searchParams.get("display_token") === displayToken;
-        return belongsToCheckout && sameToken ? savedURL : fallback;
-    }
-    catch {
-        return fallback;
-    }
-}
 function checkoutCardURL(baseURL, checkoutID, displayToken) {
     const root = publicRoot(baseURL);
     return `${root}/v1/checkouts/${encodeURIComponent(checkoutID)}/card?display_token=${encodeURIComponent(displayToken)}`;