@itpay/cli 2.1.19 → 2.1.29

package/dist/src/commands/services.js

@@ -9,6 +9,7 @@ import { ensureIdeImageAttach } from "../render/ide.js";
 import { buildCheckoutHandoff, shouldPrepareLocalCheckoutImage } from "./checkout_handoff.js";
 import { localizeCardURL, normalizeCardLocale } from "../render/locale.js";
 import { buildAgentChatHandoff } from "../render/markdown.js";
+import { refundStateEnvelope } from "./refund.js";
 import { decodeRailCatalogJourneys } from "./rail_catalog.js";
 import { platformKeyForHost } from "../render/plan.js";
 import { renderTerminalQR } from "../render/qr.js";
@@ -17,7 +18,7 @@ import { renderTerminalQR } from "../render/qr.js";
 // The server alone decides service version, quota and provider credentials.
 const RAIL_PROGRESSIVE_FEATURES = ["rail.progressive.v2"];
 import { buildCheckoutQRPlan } from "./buy.js";
-import { appendFeedbackPostmortemInstruction, CommandContractError, isTerminalServiceExecutionStatus, writeCommandEnvelope, } from "./guidance.js";
+import { appendFeedbackPostmortemInstruction, CommandContractError, isTerminalServiceExecutionStatus, writeCommandEnvelope, shellArgument, plainValueLines, } from "./guidance.js";
 // AUTH04: record the pause point of each Service Execution so a later
 // `itpay auth login` can resume the SAME task. Ids/stage/resume command only —
 // no chat content, PII or credentials. Best-effort: journaling never breaks
@@ -35,24 +36,24 @@ function journalTaskState(serviceExecutionID, envelope, env) {
 const serviceActionStatuses = new Set(["pending", "approved", "rejected", "expired", "cancelled"]);
 const RAIL_SERVICE_GUIDANCE = {
     "itpay-rail-exact": {
-        when_to_use: "出发和到达都是明确的火车站名时使用本服务（直达查询，最快）。只有城市、模糊位置或想要方案推荐时改用 itpay-rail-smart。",
+        when_to_use: "已知可信站对时先用本服务核验直达；城市需求可先形成有依据的站对假设。只覆盖这一站对，不代表全城市最优。首次查询前先留2–4行路线摘要，具体方法：itpay docs show rail-booking。",
         input_fields: [
-            { name: "origin", required: true, description: "出发火车站名（如'古镇'），不能是城市或地址", example: "古镇" },
-            { name: "destination", required: true, description: "到达火车站名（如'广州南'）", example: "广州南" },
-            { name: "travel_date", required: true, description: "出行日期 YYYY-MM-DD；字段名必须是 travel_date，'date' 等别名无效", example: "2026-09-19" },
+            { name: "origin", required: true, description: "已核实出发铁路站完整名称，不能以同名站代替区域", example: "<已核实出发站>" },
+            { name: "destination", required: true, description: "已核实到达铁路站完整名称", example: "<已核实到达站>" },
+            { name: "travel_date", required: true, description: "出行日期 YYYY-MM-DD；字段名必须是 travel_date，'date' 等别名无效", example: "<用户日期 YYYY-MM-DD>" },
         ],
-        input_example: { origin: "古镇", destination: "广州南", travel_date: "2026-09-19" },
+        input_example: { origin: "<已核实出发站名>", destination: "<已核实到达站名>", travel_date: "<用户出行日期 YYYY-MM-DD>" },
         notes: [
             "本服务只接受这三个字段，多传字段会被供应商拒绝",
-            "站名不确定就改用 itpay-rail-smart 先解析位置，不要在两个服务之间反复试错",
+            "查询为空只说明这一已解析站对；允许中转可用Smart保持双站；改变用户指定站须先取得同意",
         ],
     },
     "itpay-rail-smart": {
-        when_to_use: "只有城市名、模糊位置或需要中转规划与方案推荐时使用本服务；平台负责把位置解析到车站。",
+        when_to_use: "需要广泛站点比较、中转或具体地址接驳时使用；有可信站对且只需先核验直达可用 Exact。首次查询前先留2–4行路线摘要，具体方法：itpay docs show rail-booking。",
         input_fields: [
-            { name: "origin", required: true, description: "出发地：已知最完整的位置名或区域（城市/区县/地址均可）", example: "中山古镇" },
-            { name: "destination", required: true, description: "目的地：与 origin 同样的位置规则", example: "广州南" },
-            { name: "travel_date", required: true, description: "出行日期 YYYY-MM-DD；字段名必须是 travel_date", example: "2026-09-19" },
+            { name: "origin", required: true, description: "出发地：已知最完整的位置名或区域（城市/区县/地址均可）", example: "<原始完整地点>" },
+            { name: "destination", required: true, description: "目的地：与 origin 同样的位置规则", example: "<已核实到达站>" },
+            { name: "travel_date", required: true, description: "出行日期 YYYY-MM-DD；字段名必须是 travel_date", example: "<用户日期 YYYY-MM-DD>" },
         ],
         optional_fields: [
             { name: "origin_city", description: "出发地城市提示，辅助位置解析" },
@@ -60,48 +61,51 @@ const RAIL_SERVICE_GUIDANCE = {
             { name: "origin_location", description: "已知坐标对象（高德 GCJ-02）" },
             { name: "destination_location", description: "目的地坐标对象" },
             { name: "depart_after", description: "不早于该时间出发" },
+            { name: "depart_before", description: "不晚于该时间出发" },
             { name: "arrive_before", description: "不晚于该时间到达" },
+            { name: "user_query", description: "旅行需求原话，最多4096 UTF-8字节；时间等明确条件仍填写对应结构化字段" },
+            { name: "seat_preferences", description: "已确认的席别代码数组，不填写旅客身份" },
             { name: "priority", enum: "balanced|fastest|cheapest|safest|flexible", description: "方案偏好" },
+            { name: "duration_basis", enum: "rail|door_to_door", description: "最快默认按铁路全程含换乘；明确要求且接驳证据完整时可按门到门" },
             { name: "max_transfers", description: "允许中转次数，0-2" },
+            { name: "passengers", description: "成人乘客整数 1-5；不填写身份资料" },
         ],
-        input_example: { origin: "中山古镇", destination: "广州南", travel_date: "2026-09-19", priority: "fastest" },
+        input_example: { origin: "<用户出发地点>", destination: "<用户目的地>", travel_date: "<用户出行日期 YYYY-MM-DD>", priority: "fastest", passengers: 1 },
         notes: [
             "位置有歧义时会进入位置确认步骤，请用户选定后继续同一执行",
             "推荐结果含每趟车的席别与余票；购票在后续受保护流程完成",
         ],
     },
 };
-function railServiceGuidance(serviceID) {
-    return RAIL_SERVICE_GUIDANCE[serviceID];
+function railServiceGuidance(serviceID, schema) {
+    const guidance = RAIL_SERVICE_GUIDANCE[serviceID];
+    if (serviceID !== "itpay-rail-smart" || !guidance || !schema?.properties?.endpoints)
+        return guidance;
+    return {
+        ...guidance,
+        input_fields: [
+            { name: "endpoints", required: true, description: "origin/destination 各填 kind(area/place/station) 与完整 text；不确定 kind 可省略" },
+            { name: "travel_date", required: true, description: "用户出行日期 YYYY-MM-DD" },
+        ],
+        optional_fields: (guidance.optional_fields ?? []).filter((field) => !["origin_city", "destination_city", "origin_location", "destination_location"].includes(field.name)).concat([
+            { name: "reuse_from", description: "同 owner 的已保存 Exact result_item_id 或 Smart snapshot_id；端点/日期新查询可复用有效事实" },
+        ]),
+        input_example: { endpoints: { origin: { kind: "area", text: "<用户出发市县镇完整名称>" }, destination: { kind: "station", text: "<已核实到达站名>" } }, travel_date: "<用户出行日期 YYYY-MM-DD>" },
+        notes: ["仅用当前 input_schema 支持的端点写法；不要与旧 origin/destination 混用", "唯一地点直接解析；真实歧义只询问有缺口的一端，外部故障按当前执行恢复"],
+    };
 }
 const WORKFLOW_STEP_GUIDANCE = {
-    input: { meaning: "输入校验", hint: "对照服务声明的输入契约补齐字段后重新发起" },
-    quota: { meaning: "额度检查", hint: "免费额度或限流未通过；登录或稍后重试" },
-    geo: { meaning: "位置解析", hint: "检查 origin/destination 是否为真实地名；可附 origin_city 或坐标对象提示" },
-    geo_confirm: { meaning: "确认后位置解析", hint: "用户确认的地点仍未解析成功；重新执行并让用户从候选项中按名称+坐标选择" },
-    resolved: { meaning: "位置解析复核", hint: "位置解析未满足继续条件；检查 origin/destination 后新建执行重试" },
-    resolved_after_confirm: { meaning: "位置确认复核", hint: "确认后的位置仍未通过复核；重新执行并核对用户所选候选项" },
-    search: { meaning: "供应商车次检索", hint: "最常见是字段名错误（必须是 travel_date）或站名不存在；按 itpay docs show rail-booking 核对输入" },
-    catalog: { meaning: "可行车次计算", hint: "位置已解析但无可行车次；换日期或换站点重试" },
-    recommend: { meaning: "方案推荐", hint: "候选集无法产出推荐；放宽条件或换日期重试" },
-    delivery: { meaning: "交付", hint: "结果组装失败；稍后重试或联系运营" },
+    input: { meaning: "输入校验", hint: "核对本服务的输入契约和服务端错误码；本执行的输入不能凭猜测修复" },
+    quota: { meaning: "额度检查", hint: "查看实际额度及授权状态；只按返回的登录或等待动作处理" },
+    geo: { meaning: "位置解析", hint: "查看实际地点解析错误；有歧义时让用户选择返回的候选" },
+    geo_confirm: { meaning: "确认后位置解析", hint: "核对服务端记录的候选与用户实际选择" },
+    resolved: { meaning: "位置解析复核", hint: "查看未满足的实际位置条件" },
+    resolved_after_confirm: { meaning: "位置确认复核", hint: "核对已确认地点与服务端复核结果" },
+    search: { meaning: "供应商车次检索", hint: "查看供应商返回的错误码与当前站对；不要推断是字段或站名错误" },
+    catalog: { meaning: "可行车次计算", hint: "查看已保存结果和实际过滤原因；不要无原因改日期或站点" },
+    recommend: { meaning: "方案推荐", hint: "查看已保存候选和实际推荐失败原因；不要无原因放宽条件" },
+    delivery: { meaning: "交付", hint: "读取当前执行状态；已有订单或付款状态不明时先核实，不重建" },
 };
-function failedWorkflowStep(steps, errorCode) {
-    if (!steps)
-        return undefined;
-    for (const [step, status] of Object.entries(steps)) {
-        if (status === "failure" && step !== "failure")
-            return step;
-    }
-    // Only a backend-recorded condition_unmet proves a false branch routed to failure.
-    if (errorCode === "condition_unmet") {
-        for (const [step, status] of Object.entries(steps)) {
-            if (status === "false" && step !== "failure")
-                return step;
-        }
-    }
-    return undefined;
-}
 export async function runServicesStart(backend, serviceID, options = {}) {
     const host = options.host ?? "terminal";
     const response = await backend.startServiceExecution({
@@ -114,11 +118,11 @@ export async function runServicesStart(backend, serviceID, options = {}) {
         },
     });
     if (response.workflow_entry) {
-        const guidance = railServiceGuidance(serviceID);
+        const guidance = railServiceGuidance(serviceID, response.workflow_entry.input_schema);
         writeCommandEnvelope({
             status: "input_required",
             result: { service_execution_id: response.execution.service_execution_id, service_id: serviceID, input_schema: response.workflow_entry.input_schema, ...(guidance ? { guidance } : {}) },
-            instruction: guidance ? "按 result.guidance 逐项填写输入（when_to_use 说明本服务适用场景、input_fields 是必填契约、input_example 可直接照抄），然后继续同一服务执行。不要臆造字段名。" : "根据服务声明填写输入，然后继续同一服务执行。",
+            instruction: guidance ? "按 result.guidance 逐项填写输入（when_to_use 说明本服务适用场景、input_fields 是必填契约、input_example 是待填示意，必须替换用户真实值），然后继续同一服务执行。不要臆造字段名。" : "根据服务声明填写输入，然后继续同一服务执行。",
             next: null,
             interaction: {
                 schema_version: "itpay.interaction.v1",
@@ -191,18 +195,29 @@ function locationConfirmationEnvelope(executionID, capabilityID, input, confirma
     input = (confirmation.input ?? input);
     const endpoints = (confirmation.endpoints ?? []);
     const choices = Object.fromEntries(endpoints.map((endpoint) => [endpoint.side, "<用户选择的候选 id>"]));
+    const missing = endpoints.filter((endpoint) => !endpoint.candidates?.length);
+    const reason = missing[0]?.reason?.toUpperCase();
+    const instruction = missing.length
+        ? reason === "STATION_LOCATION_EVIDENCE_REQUIRED"
+            ? "尚未查票。车站身份已知，但 Smart 缺少该站地理坐标证据；请说明此系统缺口。若用户仅要双站直达，可按原站名使用 Exact；不要要求用户换站。"
+            : reason === "ADDRESS_REQUIRED" || reason === "ADMINISTRATIVE_AREA_UNRESOLVED"
+                ? "尚未查票。请只向用户询问该端点缺少的具体地址或行政归属；保留另一端和已有条件，得到信息后发起关联新查询。"
+                : reason === "COORDINATE_IDENTITY_UNVERIFIED" || reason === "COORDINATE_NAME_MISMATCH"
+                    ? "尚未查票。提交的地点名称和坐标尚未得到一致证据；请核实该端点的真实名称或位置，保留另一端，不要把坐标声明当成人工确认。"
+                    : "尚未查票。地点证据不足；请说明返回的具体原因与受影响端点，不要把外部故障当作用户地点歧义。"
+        : "尚未查票。仅向用户确认有真实歧义的端点，展示候选名称、地址和高德链接。用户选择后保留原输入，回到同一服务。";
     return {
         status: "location_confirmation_required",
         result: { service_execution_id: executionID, query: input, location_confirmation: confirmation },
-        instruction: "尚未查票。仅向用户确认 endpoints 中有歧义的地点，展示真实候选名称、地址和高德链接。不要自行选择候选、把区域改成车站或重复调用原查询。用户选择后保留原输入，带 location_confirmation 回到同一服务。没有候选时请用户补充已知城市或准确地名，再使用修正输入查询。",
+        instruction,
         next: null,
-        ...(confirmation.can_resume ? {
+        ...(confirmation.can_resume && !missing.length && endpoints.length ? {
             interaction: {
                 schema_version: "itpay.interaction.v1",
                 stage: "location_confirmation_required",
                 input_template: {
-                    command: `itpay services invoke ${executionID} --capability ${capabilityID}${formatInputOptions({ ...input,
-                        location_confirmation: { plan_id: confirmation.plan_id, token: confirmation.token, choices } })} --json`,
+                    command: `itpay services invoke ${executionID} --capability ${capabilityID} --input-json <地点确认.json> --json`,
+                    input: { ...input, location_confirmation: { plan_id: confirmation.plan_id, token: confirmation.token, choices } },
                     required_input: ["choices"],
                     executable: false,
                 },
@@ -217,6 +232,8 @@ function requiredInputFields(schema) {
 }
 function locationInputInstruction(schema) {
     const properties = schema?.properties;
+    if (properties?.endpoints)
+        return " 两端分别填写 endpoints.origin/destination 的 kind 与完整 text；不确定 kind 可省略。区域保留范围、精确车站仅在目录验证后锁定。不要混用旧 origin/destination、手填锁站或伪造坐标。唯一地点会自动解析；只有真实多候选才让用户选返回的候选 id，地图失败应按当前执行恢复。";
     if (!properties?.origin_location || !properties?.destination_location)
         return "";
     if (!properties.location_confirmation)
@@ -234,13 +251,9 @@ export async function runServicesInvoke(backend, config, serviceExecutionID, cap
     }
     const missingInput = missingRequiredInput(requestedCapability.input_schema, input);
     if (missingInput.length > 0) {
-        const correctedInput = { ...input };
-        for (const field of missingInput)
-            correctedInput[field] = "<value>";
-        throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "补齐 required_input 后重试同一个 execution；本次没有调用 Provider。", [{
-                command: `itpay services invoke ${serviceExecutionID} --capability ${capabilityID}${formatInputOptions(correctedInput)} --json`,
-                reason: "提交完整 capability 输入",
-            }]);
+        throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "只补缺失字段到小JSON文件，再提交同一执行；本次尚未调用供应商。", [], { schema_version: "itpay.interaction.v1", stage: "input_required",
+            input_template: { command: `itpay services invoke ${serviceExecutionID} --capability ${capabilityID} --input-json <file> --json`,
+                required_input: ["file", ...missingInput], executable: false } });
     }
     const idempotencyKey = await operationID(config, `service.invoke:${serviceExecutionID}:${capabilityID}:${stableInput(input)}`);
     let response;
@@ -293,9 +306,16 @@ function invokedEnvelope(response, requestedCapability, capabilities, input) {
         ...(quota ? { quota } : {}),
     };
     const preview = response.invocation?.safe_result_preview;
+    const notices = Array.isArray(preview?.notices) ? preview.notices.map((notice) => {
+        if (!notice || typeof notice !== "object" || !("code" in notice) || !("message" in notice) || typeof notice.message !== "string")
+            return notice;
+        if (!["RAIL_TRANSFER_SCOPE_LIMIT", "RAIL_TRANSFER_SEARCH_INCOMPLETE"].includes(String(notice.code)))
+            return notice;
+        return { ...notice, message: notice.message.replace(/可按主要枢纽分段查询[。；]?/g, "") };
+    }) : preview?.notices;
     if (!response.effective_quota?.exhausted && preview?.search_status === "LOCATION_CONFIRMATION_REQUIRED" && preview.location_confirmation) {
         return { value: locationConfirmationEnvelope(response.execution.service_execution_id, requestedCapability.capability_id, input, preview.location_confirmation),
-            plainResult: [JSON.stringify(preview.location_confirmation)] };
+            plainResult: plainValueLines(preview.location_confirmation) };
     }
     if (typeof preview?.catalog_total === "number") {
         baseResult.catalog = {
@@ -303,7 +323,7 @@ function invokedEnvelope(response, requestedCapability, capabilities, input) {
             recommendation: preview.recommendation,
             decision_source: preview.decision_source,
             coverage: preview.coverage,
-            notices: preview.notices,
+            notices,
             search_status: preview.search_status,
             searched_scope: preview.searched_scope,
             effective_policy_hash: preview.effective_policy_hash,
@@ -320,15 +340,15 @@ function invokedEnvelope(response, requestedCapability, capabilities, input) {
     let instruction = items.length > 0
         ? "用编号、名称和可公开字段向用户说明候选；若候选列表已满足目标就停止。只有用户明确选择并希望继续时，才提交对应编号；不要向用户提及 safe_payload、Execution 或内部 ID。"
         : `没有找到与“${queryText(input)}”匹配的结果。向用户展示本次为 0 个结果并停止。不要修改、缩短或猜测其他输入；只有用户明确提供新输入后，才能启动新的查询。`;
-    if (items.length === 0 && Array.isArray(preview?.notices)) {
-        const railNotice = preview.notices.find((notice) => {
+    if (items.length === 0 && Array.isArray(notices)) {
+        const railNotice = notices.find((notice) => {
             if (!notice || typeof notice !== "object")
                 return false;
             const value = notice;
             return ["RAIL_TRANSFER_SCOPE_LIMIT", "RAIL_TRANSFER_SEARCH_INCOMPLETE"].includes(String(value.code)) && typeof value.message === "string";
         });
         if (railNotice)
-            instruction = `向用户展示官方提示：${railNotice.message} 不要断言该行程必须多次中转或没有车。等待用户选择分段查询的起终点，不自动更换输入或重试。`;
+            instruction = `向用户展示官方提示：${railNotice.message} 说明本次已查范围和未完成原因，按服务端提供的当前动作恢复；不能据此断言没有车，不默认扩大范围或让用户另选分段站点。`;
     }
     let next = null;
     if (items.length > 0 && baseResult.catalog) {
@@ -374,13 +394,6 @@ function invokedEnvelope(response, requestedCapability, capabilities, input) {
         ? {
             schema_version: "itpay.interaction.v1",
             stage: "query_results_ready",
-            by_goal: {
-                compare: { action: "present_options", max_options: 3, stop_after_presentation: true },
-                prepare_checkout: {
-                    action: "select_under_user_rules_then_prepare",
-                    requires: ["current_delegation", "eligible_current_selection", "owner_permits_next_step"],
-                },
-            },
             input_template: {
                 command: `itpay services action ${response.execution.service_execution_id} --action select_candidate --actor-type human --status approved --candidate <rank> --json`,
                 required_input: ["rank"],
@@ -396,40 +409,7 @@ function invokedEnvelope(response, requestedCapability, capabilities, input) {
     };
 }
 function serviceResultPlainLines(result) {
-    const lines = [
-        `service_execution_id: ${String(result.service_execution_id)}`,
-        `capability_id: ${String(result.capability_id)}`,
-    ];
-    const items = result.items;
-    const query = result.query;
-    if (query) {
-        for (const [key, value] of Object.entries(query))
-            lines.push(`${key}: ${String(value)}`);
-    }
-    if (items.length === 0)
-        lines.push("results: 0");
-    const catalog = result.catalog;
-    if (catalog?.resolved_locations)
-        lines.push(`resolved_locations: ${JSON.stringify(catalog.resolved_locations)}`);
-    if (catalog?.journey_summary) {
-        for (const key of ["journey_summary", "train_services", "journeys"]) {
-            lines.push(`${key}: ${JSON.stringify(catalog[key])}`);
-        }
-    }
-    if (result.quota)
-        lines.push(`quota: ${JSON.stringify(result.quota)}`);
-    if (result.checkout)
-        lines.push(`checkout: ${JSON.stringify(result.checkout)}`);
-    if (items.length > 0) {
-        lines.push("items:");
-        for (const item of items) {
-            lines.push(`  ${item.rank}. ${item.title}`);
-            for (const [key, value] of Object.entries(item.safe_payload)) {
-                lines.push(`     ${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
-            }
-        }
-    }
-    return lines;
+    return plainValueLines(result);
 }
 function queryText(input) {
     const value = Object.values(input).find((item) => typeof item === "string" && item.trim() !== "");
@@ -523,11 +503,6 @@ function formatInputOptions(input) {
         : ` --input ${shellArgument(`${key}=${typeof value === "object" && value !== null ? JSON.stringify(value) : String(value)}`)}`)
         .join("");
 }
-function shellArgument(value) {
-    if (/^[\p{L}\p{N}._:=/-]+$/u.test(value))
-        return value;
-    return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
 export async function runServicesAction(backend, serviceExecutionID, actionType, input, options = {}) {
     const selection = await resolveCandidateSelection(backend, serviceExecutionID, actionType, options);
     const request = {
@@ -673,13 +648,10 @@ export async function runServicesCheckout(backend, config, serviceExecutionID, c
         const lockedInput = options.lockedInput ?? {};
         const missingInput = missingRequiredInput(capability.input_schema, lockedInput);
         if (missingInput.length > 0 && !readModel.workflow_entry && readModel.execution.next_action !== "create_checkout") {
-            throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "补齐付费 capability 的 required_input；本次没有创建 quote、Checkout 或订单。", [{ command: checkoutCommand(serviceExecutionID, capability, lockedInput), reason: "提交完整且会被锁定的服务输入" }]);
+            throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "补齐付费 capability 的 required_input；本次没有创建 quote、Checkout 或订单。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: checkoutCommand(serviceExecutionID, capability, lockedInput), required_input: missingInput, executable: false } });
         }
         if (capability.delivery_email_required && readModel.workflow_entry?.capability_id !== capability.capability_id && String(deliveryContact.email ?? "").trim() === "") {
-            throw new CommandContractError("delivery_email_required", "delivery email is required before creating this service checkout", "该 capability 的交付链接会发送到用户邮箱；先向用户说明用途并询问邮箱，不要代填。", [{
-                    command: `itpay services checkout ${serviceExecutionID} --capability ${capability.capability_id}${formatInputOptions(lockedInput)} --email <email> --json`,
-                    reason: "使用用户提供的邮箱创建 Checkout",
-                }]);
+            throw new CommandContractError("delivery_email_required", "delivery email is required before creating this service checkout", "该 capability 的交付链接会发送到用户邮箱；先向用户说明用途并询问邮箱，不要代填。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: `itpay services checkout ${serviceExecutionID} --capability ${capability.capability_id}${formatInputOptions(lockedInput)} --email <email> --json`, required_input: ["email"], executable: false } });
         }
     }
     const response = await backend.createServiceExecutionCheckout(serviceExecutionID, {
@@ -695,6 +667,33 @@ export async function runServicesCheckout(backend, config, serviceExecutionID, c
     const checkoutURL = tokenizedCheckoutURL(checkout.checkout_url, displayToken, checkout.qr_payload);
     const cardURL = localizeCardURL(absolutePublicURL(config.baseURL, checkout.card_url ?? fallbackCardURL(config.baseURL, checkoutID, displayToken)), locale);
     const cardPNGURL = localizeCardURL(absolutePublicURL(config.baseURL, checkout.card_png_url ?? checkout.qr_png_url ?? fallbackCardPNGURL(config.baseURL, checkoutID, displayToken)), locale);
+    let itineraryTitle;
+    let itinerary;
+    try {
+        const booking = await backend.getServiceExecution(serviceExecutionID);
+        if (booking.execution.service_id === "itpay-rail-booking") {
+            const leg = booking.rail_booking?.legs?.[0];
+            const review = booking.workflow?.human_action?.context?.review;
+            const reviewLeg = Array.isArray(review?.legs) ? review.legs[0] : undefined;
+            const facts = leg ?? reviewLeg;
+            if (facts) {
+                const safe = facts;
+                itinerary = { travel_date: safe.travel_date, train_code: safe.train_code,
+                    from_station: safe.from ?? safe.from_station, to_station: safe.to ?? safe.to_station,
+                    departure: safe.departure, arrival: safe.arrival,
+                    seat_name: safe.seat_name ?? safe.seat_type_name,
+                    passengers: review?.passengers ?? safe.passengers ?? null };
+                itineraryTitle = [facts.travel_date, facts.train_code,
+                    facts.from ?? facts.from_station,
+                    "→", facts.to ?? facts.to_station,
+                    facts.seat_name ?? facts.seat_type_name]
+                    .filter((value) => typeof value === "string" && value.length > 0).join(" ");
+            }
+        }
+    }
+    catch {
+        // Checkout already exists; a display-only title lookup cannot hide its official handoff.
+    }
     const plan = buildCheckoutQRPlan({
         host,
         checkoutID,
@@ -705,7 +704,7 @@ export async function runServicesCheckout(backend, config, serviceExecutionID, c
         qrPNGURL: cardPNGURL,
         nextAction: checkout.checkout.next_action,
         orderItems: response.cart.items.map((item) => ({
-            title: item.title,
+            title: itineraryTitle || item.title,
             quantity: item.quantity,
             amountMinor: item.amount_minor,
             currency: item.currency,
@@ -742,13 +741,9 @@ export async function runServicesCheckout(backend, config, serviceExecutionID, c
         });
     }
     const envelope = buildServicesCheckoutEnvelope(response, checkoutURL, plan, options.agentType, options.target);
-    const plainResult = [
-        `service_execution_id: ${response.binding.service_execution_id}`,
-        `checkout_id: ${checkoutID}`,
-        `capability_id: ${checkoutCapabilityID(response, capabilityID)}`,
-        `locked_input: ${JSON.stringify(response.locked_input)}`,
-        `amount: ${formatMoney(checkout.checkout.amount_minor, checkout.checkout.currency)}`,
-    ];
+    if (itinerary)
+        envelope.result = { ...envelope.result, itinerary };
+    const plainResult = plainValueLines(envelope.result);
     if (!options.jsonOutput && platform === "terminal") {
         plainResult.push("qr:", await renderTerminalQR(checkoutURL, options.qrFormat ?? "terminal"));
     }
@@ -768,14 +763,14 @@ export async function runServicesQuote(backend, serviceExecutionID, capabilityID
         model.allowed_actions?.some((action) => action.type === "prepare_quote" && action.capability_id === capabilityID);
     const missingInput = missingRequiredInput(capability.input_schema, input);
     if (missingInput.length > 0 && !selectionBacked && model.workflow_entry?.capability_id !== capability.capability_id) {
-        throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "补齐付费 capability 输入；本次没有创建 Quote、Cart 或 Checkout。", [{ command: quoteCommand(serviceExecutionID, capability, input), reason: "提交完整且会被锁定的输入" }]);
+        throw new CommandContractError("capability_input_invalid", `missing required capability input: ${missingInput.join(", ")}`, "补齐付费 capability 输入；本次没有创建 Quote、Cart 或 Checkout。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: quoteCommand(serviceExecutionID, capability, input), required_input: missingInput, executable: false } });
     }
     const deliveryContact = {
         ...(options.deliveryContact ?? {}),
         ...(options.email ? { email: options.email } : {}),
     };
     if (capability.delivery_email_required && model.workflow_entry?.capability_id !== capability.capability_id && String(deliveryContact.email ?? "").trim() === "") {
-        throw new CommandContractError("delivery_email_required", "delivery email is required before preparing this service quote", "交付链接会发送到用户邮箱；说明用途并询问邮箱，不要代填。", [{ command: quoteCommand(serviceExecutionID, capability, input), reason: "使用用户提供的邮箱创建报价" }]);
+        throw new CommandContractError("delivery_email_required", "delivery email is required before preparing this service quote", "交付链接会发送到用户邮箱；说明用途并询问邮箱，不要代填。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: quoteCommand(serviceExecutionID, capability, input), required_input: ["email"], executable: false } });
     }
     const quote = await backend.prepareServiceQuote(serviceExecutionID, {
         capability_id: capabilityID,
@@ -840,27 +835,44 @@ export async function runServicesGet(backend, serviceExecutionID, options = {})
         status: nextState.status,
         result,
         instruction: nextState.instruction,
-        next: nextState.next ? { command: nextState.next.command, reason: "继续当前首选动作" } : null,
-        recovery: nextState.recovery,
+        next: nextState.next,
+        ...(nextState.interaction ? { interaction: nextState.interaction } : {}),
+        ...(nextState.communication ? { communication: nextState.communication } : {}),
+        ...(nextState.handoff ? { handoff: nextState.handoff } : {}),
+        recovery: nextState.recovery.filter(action => action.command !== `itpay services get ${serviceExecutionID} --json`),
     };
     writeCommandEnvelope(envelope, {
         ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
         ...(options.output ? { output: options.output } : {}),
-        plainResult: [
-            `service_execution_id: ${execution.service_execution_id}`,
-            `service_id: ${execution.service_id}`,
-            `state: ${execution.status}/${execution.phase}`,
-            ...(execution.current_capability_id ? [`current_capability_id: ${execution.current_capability_id}`] : []),
-            ...timeline.map((event) => `${event.sequence}. ${event.step} ${event.status}/${event.phase} ${event.occurred_at}`),
-        ],
+        plainResult: plainValueLines(envelope.result),
     });
 }
+function shouldWaitForServiceResult(model) {
+    if (model.current_delivery || model.rail_booking || isTerminalServiceExecutionStatus(model.execution.status))
+        return false;
+    if (model.rail_planning) {
+        const plan = model.rail_planning;
+        return !plan.recommendation && !(plan.alternatives?.length) &&
+            !["complete", "paused", "failed", "cancelled", "expired"].includes(plan.search?.expansion_status ?? "") &&
+            !plan.available_actions?.some((action) => ["select_journey", "confirm_location", "expand_search"].includes(action.type));
+    }
+    return ["queued", "running", "delivery"].includes(model.workflow?.status ?? "");
+}
 export async function runServicesNext(backend, serviceExecutionID, options = {}) {
-    const response = await backend.getServiceExecution(serviceExecutionID, options.sinceSnapshot ? { sinceSnapshot: options.sinceSnapshot } : {});
+    const started = Date.now();
+    const until = started + (options.timeoutSeconds ?? 0) * 1000;
+    const sleep = options.sleep ?? ((milliseconds) => new Promise(resolve => setTimeout(resolve, milliseconds)));
+    let response = await backend.getServiceExecution(serviceExecutionID, options.sinceSnapshot ? { sinceSnapshot: options.sinceSnapshot } : {});
+    while (shouldWaitForServiceResult(response) && Date.now() < until) {
+        await sleep(options.pollIntervalMS ?? Math.max(1500, response.rail_planning?.search?.poll_after_ms ?? 0));
+        response = await backend.getServiceExecution(serviceExecutionID, options.sinceSnapshot ? { sinceSnapshot: options.sinceSnapshot } : {});
+    }
     const envelope = servicesNextEnvelope(response);
+    if (shouldWaitForServiceResult(response) && options.timeoutSeconds) {
+        envelope.result = { ...envelope.result, waited_seconds: Math.round((Date.now() - started) / 1000), wait_timed_out: true };
+        envelope.next = { command: `itpay services next ${serviceExecutionID} --timeout 120 --json`, reason: "稍后继续等待同一任务；不重新提交查询" };
+    }
     journalTaskState(serviceExecutionID, envelope, options.env ?? process.env);
-    if (response.rail_booking)
-        envelope.result = { ...envelope.result, rail_booking: response.rail_booking };
     writeCommandEnvelope(envelope, {
         ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
         ...(options.output ? { output: options.output } : {}),
@@ -879,6 +891,33 @@ export async function runServicesPage(backend, serviceExecutionID, resultItemID,
     const response = await backend.getServiceExecutionResultItemPage(serviceExecutionID, resultItemID, offset, limit);
     const page = response.page;
     const container = (page.result ?? page);
+    const exactCandidate = limit === 1 && Array.isArray(container.candidates) && container.candidates.length === 1
+        ? container.candidates[0] : undefined;
+    if (exactCandidate && typeof exactCandidate.train_code === "string" && Array.isArray(exactCandidate.seats)) {
+        const offer = exactCandidate.booking_offer;
+        const { booking_offer: _bookingOffer, ...candidateFacts } = exactCandidate;
+        const seats = exactCandidate.seats.filter((seat) => seat.purchase_supported === true);
+        writeCommandEnvelope({
+            status: "exact_train_detail",
+            result: {
+                service_execution_id: serviceExecutionID, result_item_id: resultItemID, result_offset: offset,
+                candidate: candidateFacts,
+                ...(offer?.service_id && offer.selection_token ? { booking_template: {
+                        command: `itpay services run ${offer.service_id} --input-json <file> --json`,
+                        executable: false, required_input: ["file", "passengers", "seat_type"],
+                        seat_choices: seats.map((choice) => ({ seat_type: choice.seat_type, seat_name: choice.seat_name })),
+                        input_example: { selection: { token: offer.selection_token, seat_type: "<用户授权席别对应代码>" }, passengers: "<真实人数>" },
+                    } } : {}),
+            },
+            instruction: offer?.selection_token
+                ? "这是已保存车次的当前详情；只按 purchase_supported 席别代码、库存与报价状态选择。购票模板的人数须按用户真实需求填写；查询价需在后续报价确认。若用户仅要求比较，答复后停止。"
+                : "这条车次当前没有可用的购买凭据；说明席别与余票事实，不要猜测代码或构造订单。",
+            next: null, recovery: [],
+        }, { ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
+            ...(options.output ? { output: options.output } : {}),
+        });
+        return;
+    }
     // rail.progressive.v2 saved pages key journeys/journey_page; legacy result
     // items key candidates/catalog_page. Both are committed, read-only slices.
     const v2Page = (container.journey_page ?? {});
@@ -897,7 +936,9 @@ export async function runServicesPage(backend, serviceExecutionID, resultItemID,
             total: catalogPage.total ?? candidates.length,
             count: catalogPage.count ?? candidates.length,
             next_offset: nextOffset,
-            page,
+            ...(journeys.length ? { journeys: journeys.map(value => compactRailJourney(value, serviceExecutionID, resultItemID)) }
+                : candidates.some(value => typeof value === "object" && value !== null && "train_code" in value)
+                    ? { candidates: candidates.map((value, index) => exactTrainRow(value, serviceExecutionID, resultItemID, (catalogPage.offset ?? offset) + index)) } : { page }),
         },
         instruction: "读取的是已保存结果的同版本分页，不重新查询、不消耗额度。先读完所需页，再合并回答用户；不要逐页播报。",
         next: nextOffset !== null
@@ -913,11 +954,7 @@ export async function runServicesPage(backend, serviceExecutionID, resultItemID,
     writeCommandEnvelope(envelope, {
         ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
         ...(options.output ? { output: options.output } : {}),
-        plainResult: candidates.map((candidate) => {
-            const c = candidate;
-            const title = typeof c.title === "string" ? c.title : JSON.stringify(c);
-            return `${title}`;
-        }),
+        plainResult: plainValueLines(envelope.result),
     });
 }
 export async function runServicesList(backend, options = {}) {
@@ -932,6 +969,7 @@ export async function runServicesList(backend, options = {}) {
         status: execution.status,
         phase: execution.phase,
         updated_at: execution.updated_at,
+        reader: { command: `itpay services next ${execution.service_execution_id} --json`, reason: "读取这笔已有服务" },
     }));
     const latest = executions[0];
     const envelope = {
@@ -940,7 +978,7 @@ export async function runServicesList(backend, options = {}) {
         instruction: executions.length === 1
             ? "只有一条可恢复记录；继续读取同一笔服务。"
             : latest
-                ? "用服务和状态说明这些可恢复记录；多个结果必须让用户选择。"
+                ? "按原任务中已明确的执行ID读取对应reader；只有无法确定属于哪一笔任务时才询问用户。"
                 : "当前设备没有可恢复的 Service Execution；先读取已发布目录，不要猜测 ID。",
         next: executions.length === 1
             ? { command: `itpay services next ${latest.service_execution_id} --json`, reason: "继续唯一可恢复的服务" }
@@ -952,55 +990,178 @@ export async function runServicesList(backend, options = {}) {
     writeCommandEnvelope(envelope, {
         ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
         ...(options.output ? { output: options.output } : {}),
-        plainResult: executions.map((execution) => `${execution.service_execution_id}: ${execution.service_id} ${execution.status}/${execution.phase} updated=${execution.updated_at}`),
     });
 }
+// Bound the final qualified output by whole saved rows; the cursor follows the emitted rows.
+function writeSavedRailPage(envelope, options, key, offset, continuation) {
+    const result = envelope.result ?? {};
+    const rows = result[key];
+    if (!Array.isArray(rows))
+        throw new Error("saved page has no rows");
+    const bound = (offset === 0 ? 12 : 32) * 1024;
+    const render = (output) => writeCommandEnvelope(envelope, { ...options, output });
+    if (!options.all) {
+        for (;;) {
+            let text = "";
+            render(value => { text += value; });
+            if (Buffer.byteLength(text, "utf8") <= bound)
+                break;
+            if (rows.length <= 1) {
+                throw new CommandContractError("saved_row_too_large", "saved row exceeds the readable page limit", "这条已保存记录超过当前页面大小；事实仍保留，请读取该条详情。", rows[0]?.detail?.command ? [rows[0].detail] : []);
+            }
+            rows.pop();
+            result.count = rows.length;
+            if (key === "trains")
+                result.read_count = rows.length;
+            result.next_offset = offset + rows.length;
+            envelope.next = continuation(offset + rows.length);
+        }
+    }
+    writeCommandEnvelope(envelope, options);
+}
 export async function runServicesReadResult(backend, serviceExecutionID, options = {}) {
+    if (!options.snapshot && !options.journey) {
+        const model = await backend.getServiceExecution(serviceExecutionID);
+        if (model.execution.service_id === "itpay-rail-exact") {
+            const item = (model.current_result_items?.length ? model.current_result_items : model.result_items)?.[0];
+            if (!item) {
+                const preview = model.provider_invocations.at(-1)?.safe_result_preview;
+                const template = exactSmartTemplate(preview?.resolved_station_pair, serviceExecutionID);
+                if (template && preview?.catalog_total === 0) {
+                    writeCommandEnvelope({ status: "no_result", result: { service_execution_id: serviceExecutionID,
+                            scope: "station_pair", resolved_station_pair: preview.resolved_station_pair,
+                            total: 0, smart_template: template },
+                        instruction: "这一站对的成功观测为0条，不代表附近区域无车。若用户允许中转或原需求范围更广，保留原始区域/地点意图并沿 smart_template 引用本次事实；只要直达时不要自动转中转。",
+                        next: null, recovery: [] }, { ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
+                        ...(options.output ? { output: options.output } : {}) });
+                    return;
+                }
+                await runServicesNext(backend, serviceExecutionID, options);
+                return;
+            }
+            const rows = [];
+            const startOffset = options.offset ?? 0;
+            const limit = options.limit ?? 20;
+            if (!Number.isInteger(startOffset) || startOffset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 20) {
+                throw new CommandContractError("page_invalid", "offset must be non-negative and limit 1-20", "页码无效；请按返回的 next.command 读取。", []);
+            }
+            let offset = startOffset;
+            let total = 0;
+            let resolvedStationPair;
+            let nextOffset = startOffset;
+            do {
+                const response = await backend.getServiceExecutionResultItemPage(serviceExecutionID, item.service_capability_result_item_id, offset, limit);
+                const container = (response.page.result ?? response.page);
+                const candidates = Array.isArray(container.candidates) ? container.candidates : [];
+                resolvedStationPair ??= container.resolved_station_pair;
+                rows.push(...candidates.map((value, index) => exactTrainRow(value, serviceExecutionID, item.service_capability_result_item_id, offset + index)));
+                const page = (container.catalog_page ?? {});
+                total = typeof container.catalog_total === "number" ? container.catalog_total : Math.max(total, rows.length);
+                nextOffset = typeof page.next_offset === "number" && page.next_offset > offset ? page.next_offset : null;
+                offset = nextOffset ?? offset;
+            } while (options.all && nextOffset !== null);
+            writeSavedRailPage({
+                status: "ready",
+                result: { service_execution_id: serviceExecutionID, scope: "station_pair", resolved_station_pair: resolvedStationPair,
+                    total, offset: startOffset, count: rows.length, read_count: rows.length,
+                    ...(exactSmartTemplate(resolvedStationPair, serviceExecutionID, item.service_capability_result_item_id)
+                        ? { smart_template: exactSmartTemplate(resolvedStationPair, serviceExecutionID, item.service_capability_result_item_id) } : {}),
+                    trains: rows, ...(nextOffset !== null ? { next_offset: nextOffset } : {}) },
+                instruction: "这是同一已保存站对的车次行。按用户时限、席别和人数筛选；零条仅代表这一站对。纯比较答复后结束；已有购票委托则执行所选行 detail.command 读取当前席别、库存和购买凭据。",
+                next: nextOffset !== null ? { command: `itpay services read-result ${serviceExecutionID} --offset ${nextOffset} --limit ${limit} --json`, reason: "继续读取同一结果的剩余车次" } : null,
+                recovery: [],
+            }, { ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
+                ...(options.output ? { output: options.output } : {}),
+                all: Boolean(options.all),
+            }, "trains", startOffset, next => ({ command: `itpay services read-result ${serviceExecutionID} --offset ${next} --limit ${limit} --json`, reason: "读取同一保存结果的下一页" }));
+            return;
+        }
+    }
     // rail.progressive.v2 planning read: --journey/--snapshot select committed
     // planning evidence — a free owner-validated read that never touches the
     // grant/Vault path. Without the selectors the authorized-delivery flow is
     // unchanged.
-    // rail.planning full catalog read: --snapshot alone returns the complete
-    // committed rail.catalog.v3 — shared dictionaries and field_legend are
-    // preserved verbatim; one catalog, never split into candidates+journeys.
+    // rail.planning catalog read: --snapshot returns compact rows for the
+    // committed rail.catalog.v3; journey detail remains available separately.
     if (options.snapshot && !options.journey) {
-        const committed = await backend.getRailPlanningCatalog(serviceExecutionID, options.snapshot);
-        const catalog = committed.catalog;
-        // The committed catalog may ship shared_rows.v1 positional rows — decode
-        // the summary through the column legend; an unknown encoding is an
-        // explicit upgrade error, never an empty catalog.
-        const decoded = catalog
-            ? decodeRailCatalogJourneys(catalog)
-            : { journeys: [], packed: false };
-        const journeys = decoded.journeys;
-        const counts = (catalog?.counts ?? {});
-        const journeyCount = journeys.length || Number(counts?.combinations ?? 0);
-        writeCommandEnvelope({
+        const offset = options.offset ?? 0;
+        const limit = options.limit ?? 3;
+        if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 1 || limit > 20) {
+            throw new CommandContractError("page_invalid", "offset must be non-negative and limit 1-20", "目录页码无效；请按返回的 next.command 读取。", []);
+        }
+        const journeys = [];
+        let nextOffset = offset;
+        let total = 0;
+        let qualificationCounts;
+        let planID;
+        let queryRevision;
+        while (nextOffset !== null) {
+            let response;
+            try {
+                response = await backend.getServiceExecutionResultItemPage(serviceExecutionID, options.snapshot, nextOffset, limit);
+            }
+            catch (error) {
+                if (error instanceof HttpError && error.code === "result_not_pageable") {
+                    const committed = await backend.getRailPlanningCatalog(serviceExecutionID, options.snapshot);
+                    decodeRailCatalogJourneys(committed.catalog);
+                }
+                throw error;
+            }
+            if (response.snapshot_id !== options.snapshot)
+                throw new Error("saved page snapshot changed");
+            planID = response.plan_id;
+            queryRevision = response.query_revision;
+            const container = (response.page.result ?? response.page);
+            const page = container.journey_page;
+            const rows = Array.isArray(container.journeys) ? container.journeys : [];
+            total = typeof page?.total === "number" ? page.total : rows.length;
+            qualificationCounts = page?.qualification_counts ?? qualificationCounts;
+            journeys.push(...rows.map((card) => compactRailJourney(card, serviceExecutionID, options.snapshot)));
+            const following = page?.next_offset;
+            if (typeof following === "number" && following <= nextOffset)
+                throw new Error("saved page cursor did not advance");
+            nextOffset = typeof following === "number" ? following : null;
+            if (!options.all)
+                break;
+        }
+        writeSavedRailPage({
             status: "ready",
             result: {
                 service_execution_id: serviceExecutionID,
-                plan_id: committed.plan_id,
-                snapshot_id: committed.snapshot_id,
-                query_revision: committed.query_revision,
-                catalog,
+                plan_id: planID,
+                snapshot_id: options.snapshot,
+                query_revision: queryRevision,
+                total,
+                qualification_counts: qualificationCounts,
+                offset,
+                count: journeys.length,
+                next_offset: nextOffset,
+                journeys,
             },
-            instruction: "catalog 是本次查询的完整已保存目录。按用户问题筛选全部journeys并一次回答；只有需要单程细节时才读取journey。价格和余票供比较，购买前须实时报价。",
-            next: null,
+            instruction: qualificationCounts === undefined
+                ? "此历史快照没有完整资格计数；线路仅供核对铁路事实，不能据此认定可购买。沿同快照 detail.command 查看详情。"
+                : qualificationCounts.eligible === 0
+                    ? `查到 ${total} 个时刻组合，当前 0 条满足购票资格。请读取诊断线路的 detail.command 查看具体原因；修改条件须依据用户意愿。`
+                    : "这是同一已保存快照的完整线路分页；合格线路已排在前面。若问题需要全部方案，沿 next.command 读完再一次回答；未知费用不能当免费。购票条件用合格线路的 detail.command，价格与余票在购买前实时报价。",
+            next: nextOffset === null ? null : { command: `itpay services read-result ${serviceExecutionID} --snapshot ${options.snapshot} --offset ${nextOffset} --limit ${limit} --json`, reason: "仅当前问题还需未读线路时继续；已有合格完整结果可答复或按委托继续" },
             recovery: [],
         }, {
             ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
             ...(options.output ? { output: options.output } : {}),
-            plainResult: journeys.length > 0
-                ? [
-                    `${journeyCount} combinations:`,
-                    ...journeys.map((j) => `${j.defaultLayer === "backup" ? "[备选] " : "[主选择] "}${j.ref}  ${j.route}`),
-                ]
-                : [`catalog: ${committed.snapshot_id} (no combinations)`],
-        });
+            all: Boolean(options.all),
+        }, "journeys", offset, next => ({ command: `itpay services read-result ${serviceExecutionID} --snapshot ${options.snapshot} --offset ${next} --limit ${limit} --json`, reason: "仅当前问题还需未读线路时继续；已有合格完整结果可答复或按委托继续" }));
         return;
     }
     if (options.journey) {
         const detail = await backend.getRailJourneyDetail(serviceExecutionID, options.journey, options.snapshot);
+        const planOffset = options.offset ?? 0;
+        const planLimit = options.limit ?? 3;
+        if (!Number.isInteger(planOffset) || planOffset < 0 || !Number.isInteger(planLimit) || planLimit < 1 || planLimit > 20) {
+            throw new CommandContractError("page_invalid", "offset must be non-negative and limit 1-20", "席别方案页码无效；请按返回的 next.command 读取。", []);
+        }
+        const plans = detail.journey.ticket_plans ?? [];
+        const selected = options.all ? plans : plans.slice(planOffset, planOffset + planLimit);
+        const nextOffset = !options.all && planOffset + selected.length < plans.length ? planOffset + selected.length : null;
         writeCommandEnvelope({
             status: "ready",
             result: {
@@ -1008,17 +1169,22 @@ export async function runServicesReadResult(backend, serviceExecutionID, options
                 plan_id: detail.plan_id,
                 snapshot_id: detail.snapshot_id,
                 query_revision: detail.query_revision,
-                journey: detail.journey,
+                journey: compactRailJourney(detail.journey, serviceExecutionID, detail.snapshot_id),
+                ticket_plan_total: plans.length,
+                ticket_plan_offset: planOffset,
+                ticket_plans: selected.map(plan => compactRailTicketPlan(plan, detail.journey.qualification_status === "eligible")),
             },
-            instruction: "展示该 journey 的完整明细（车次、分段、席别报价、接驳估计与风险标注）。rail_payable 只是该行程当前可购报价的参考价，不是锁价；下单前须走受保护 Checkout 收集乘车人。",
-            next: detail.journey?.booking_support === "single_leg"
-                ? { command: `itpay services action ${serviceExecutionID} --action select_journey --actor-type human --status approved --input journey_id=${detail.journey.journey_id} --json`, reason: "选定此行程" }
-                : { command: `itpay services next ${serviceExecutionID} --since-snapshot ${detail.snapshot_id} --json`, reason: "返回规划进展" },
+            instruction: "同一线路的完整车次与席别方案。已有所需席别和有效凭据即可按真实委托继续；只需比较则答复并停止，需要其他席别才读下一页。中转各段独立购买，无联合锁票或接续保证；购买前受保护 Checkout 实时报价。",
+            next: nextOffset === null ? null : { command: `itpay services read-result ${serviceExecutionID} --snapshot ${detail.snapshot_id} --journey ${options.journey} --offset ${nextOffset} --limit ${planLimit} --json`, reason: "仅需要其他席别时读取；已满足用户条件则停止翻页" },
+            ...(detail.journey?.booking_support === "single_leg" ? { interaction: {
+                    schema_version: "itpay.interaction.v1", stage: "query_results_ready",
+                    select_user_chosen: `itpay services action ${serviceExecutionID} --action select_journey --actor-type human --status approved --input journey_id=${detail.journey.journey_id} --json`,
+                    select_delegated: `itpay services action ${serviceExecutionID} --action select_journey --actor-type agent --status approved --input journey_id=${detail.journey.journey_id} --input selection_mode=delegated --json`,
+                } } : {}),
             recovery: [],
         }, {
             ...(options.jsonOutput !== undefined ? { jsonOutput: options.jsonOutput } : {}),
             ...(options.output ? { output: options.output } : {}),
-            plainResult: servicesNextPlainResult(detail.journey),
         });
         return;
     }
@@ -1038,6 +1204,43 @@ export async function runServicesReadResult(backend, serviceExecutionID, options
         plainResult: servicesNextPlainResult(envelope.result),
     });
 }
+function exactSmartTemplate(pair, executionID, resultItemID) {
+    if (!pair || typeof pair !== "object")
+        return null;
+    const value = pair;
+    if (!["origin_name", "origin_code", "destination_name", "destination_code", "travel_date"].every((key) => typeof value[key] === "string" && value[key]))
+        return null;
+    return { executable: false, verified_station_pair: value,
+        instruction: "已核验站对是复用事实，不是完整用户查询。仅用户明确锁站才填 kind=station；区域/地点从原始需求填回，保留真实人数、时限和偏好，不默认为一人。",
+        command: "itpay services run itpay-rail-smart --input-json <原始需求.json> --json",
+        required_input: ["endpoints", "passengers", "用户时限与偏好"],
+        input_example: { endpoints: { origin: { text: "<原始出发行政范围/地点/用户指定站>" }, destination: { text: "<原始到达行政范围/地点/用户指定站>" } },
+            travel_date: value.travel_date, passengers: "<真实人数>", reuse_from: { execution_id: executionID,
+                ...(resultItemID ? { result_item_id: resultItemID } : {}) } } };
+}
+function exactTrainRow(candidate, executionID, itemID, offset) {
+    return { ...compactExactTrain(candidate), result_item_id: itemID, result_offset: offset,
+        detail: { command: `itpay services page ${executionID} ${itemID} --offset ${offset} --limit 1 --json`, reason: "读取此车次席别与服务端购买模板" } };
+}
+function compactExactTrain(candidate) {
+    const seats = Array.isArray(candidate.seats) ? candidate.seats : [];
+    return {
+        candidate_id: candidate.candidate_id,
+        train_code: candidate.train_code,
+        from_station: candidate.from_station,
+        from_station_code: candidate.from_station_code,
+        to_station: candidate.to_station,
+        to_station_code: candidate.to_station_code,
+        travel_date: candidate.travel_date,
+        departure: candidate.departure,
+        arrival: candidate.arrival,
+        purchase_supported: candidate.purchase_supported ?? Boolean(candidate.booking_offer),
+        seats: seats.map((seat) => ({ seat_type: seat.seat_type, seat_name: seat.seat_name,
+            availability_text: seat.availability_text, remaining: seat.remaining,
+            fare_minor: seat.fare_minor, quoted_total_minor: seat.quoted_total_minor,
+            purchase_supported: seat.purchase_supported, requires_price_refresh: seat.requires_price_refresh })),
+    };
+}
 function railLegSeatSummary(seat) {
     return {
         passenger_index: seat.passenger_index,
@@ -1071,15 +1274,14 @@ function railBookingEnvelope(model) {
         service_execution_id: execution.service_execution_id,
         ...(orderID ? { order_id: orderID } : {}),
         rail: { state: rail.state, issued_legs: rail.issued_legs, legs },
-        ...(model.workflow ? { workflow: model.workflow } : {}),
     };
     if (rail.state === "issued") {
         const detailsPending = rail.legs.some((leg) => leg.details_pending);
         return {
             status: "issued",
-            result,
+            result: { ...result, ...(orderID ? { aftercare: { command: `itpay order ${orderID} --json`, when: "仅用户请求核对订单或售后时" } } : {}) },
             instruction: `告诉用户：车票已出票，座位以实际出票为准，平台不提供 12306 票号，可在订单页核对行程。不要在对话中索要乘车人身份信息。${detailsPending ? "部分席位信息未能同步，请前往 12306 核对行程；不要重复购买。" : ""}`,
-            next: orderID ? { command: `itpay order ${orderID} --json`, reason: "查看订单及退款入口" } : null,
+            next: null,
             recovery: [],
         };
     }
@@ -1113,18 +1315,124 @@ function railBookingEnvelope(model) {
         recovery: [],
     };
 }
-function railJourneySummary(card, serviceExecutionID) {
+function compactRailJourney(card, serviceExecutionID, snapshotID) {
+    if (!card.journey_id)
+        throw new Error("saved journey has no stable ID");
+    const rides = (card.rides ?? []).map((ride) => ({
+        train_code: ride.train_code ?? (Array.isArray(ride.train_codes) ? ride.train_codes.join("/") : null),
+        from_station: ride.from_station ?? null, from_station_code: ride.from_station_code ?? null,
+        departure: ride.departure ?? null, to_station: ride.to_station ?? null,
+        to_station_code: ride.to_station_code ?? null, arrival: ride.arrival ?? null,
+        ...(typeof ride.wait_minutes === "number" ? { wait_minutes: ride.wait_minutes } : {}),
+        ...(typeof ride.minimum_connection_minutes === "number" ? { required_buffer_minutes: ride.minimum_connection_minutes } : {}),
+        ...(ride.same_run === true ? { same_run: true } : {}),
+    }));
+    const offer = card.representative_offer;
+    const metrics = card.representative_metrics;
+    const ticketSeats = (offer?.ticket_offers ?? []).map((raw) => ({
+        leg_index: raw.leg_index, seat_type: raw.seat_type, seat_name: raw.seat_name,
+        availability: raw.availability_text, remaining: raw.inventory_exact === true ? raw.remaining : null,
+    }));
+    const railwayTime = (value) => {
+        if (typeof value !== "string")
+            return NaN;
+        const time = value.replace(" ", "T");
+        return Date.parse(/(?:Z|[+-]\d{2}:\d{2})$/.test(time) ? time : `${time}Z`);
+    };
+    const start = railwayTime(rides[0]?.departure);
+    const end = railwayTime(rides.at(-1)?.arrival);
+    return {
+        journey_ref: card.journey_id,
+        ...(card.profile_refs?.balanced ? { profile_ref: card.profile_refs.balanced } : {}),
+        default_layer: card.default_layer ?? "main",
+        ...(card.backup_reason ? { backup_reason: card.backup_reason } : {}),
+        ...(card.backup_baseline_min != null ? { backup_baseline_min: card.backup_baseline_min } : {}),
+        ...(card.backup_delta_min != null ? { backup_delta_min: card.backup_delta_min } : {}),
+        route: card.route_text ?? (card.route_names ?? card.route ?? []).join("→"),
+        rides,
+        ...(card.booking_support === "single_leg" && card.qualification_status === "eligible" && card.booking_offer ? {
+            booking_template: { command: `itpay services run ${card.booking_offer.service_id} --input-json <购票.json> --json`, executable: false,
+                seat_choices: ticketSeats.map(seat => ({ seat_type: seat.seat_type, seat_name: seat.seat_name })),
+                input_example: { selection: { token: card.booking_offer.selection_token, seat_type: "<返回席别代码>" }, passengers: card.passengers ?? offer?.ticket_offers?.[0]?.passengers ?? "<真实人数>" },
+                required_input: ["file", "真实席别选择及人数"] },
+        } : {}),
+        ...(ticketSeats.length ? { seats: ticketSeats } : {}),
+        passengers: card.passengers ?? offer?.ticket_offers?.[0]?.passengers ?? null,
+        availability: card.availability ?? "unknown",
+        qualification_status: card.qualification_status ?? "unknown",
+        ...(card.qualification_reasons?.length ? { qualification_reasons: card.qualification_reasons } : {}),
+        ...(offer ? { rail_payable_fen: offer.rail_payable_minor, currency: offer.currency } : { rail_payable_fen: null }),
+        estimated_trip_total: metrics?.estimated_total_cost ?? null,
+        cost_basis: metrics?.cost_basis ?? "unknown",
+        duration_basis: metrics?.duration_basis ?? "unknown",
+        timezone: "Asia/Shanghai",
+        ...(card.risk_notes?.length ? { risk_notes: card.risk_notes } : {}),
+        rail_duration_minutes: Number.isFinite(start) && Number.isFinite(end) && end >= start ? Math.round((end - start) / 60000) : null,
+        ...(card.observed_at ? { observed_at: card.observed_at } : {}),
+        detail: { command: `itpay services read-result ${serviceExecutionID} --snapshot ${snapshotID} --journey ${card.journey_id} --json`,
+            reason: card.qualification_status === "eligible" ? "读取此完整线路的席别、报价和购买条件" : "读取此线路的铁路事实和不可购买原因" },
+    };
+}
+function compactRailTicketPlan(raw, journeyEligible) {
+    const legs = Array.isArray(raw.legs) ? raw.legs : [];
+    const seats = Array.isArray(raw.seat_offers) ? raw.seat_offers : [];
+    const tickets = Array.isArray(raw.ticket_offers) ? raw.ticket_offers : [];
+    return {
+        ticket_plan_ref: raw.ticket_plan_ref,
+        passengers: raw.passenger_count ?? (Array.isArray(raw.ticket_offers) ? raw.ticket_offers[0]?.passengers : null) ?? null,
+        purchase_support: raw.purchase_support ?? "none",
+        qualification_status: raw.qualification_status ?? "unknown",
+        qualification_reasons: raw.qualification_reasons ?? [],
+        rail_amount_fen: raw.rail_amount_fen ?? null,
+        service_fee_fen: raw.service_fee_fen ?? null,
+        price_verified: raw.rail_amount_verified === true,
+        legs: legs.map((leg, index) => ({
+            leg_index: index,
+            travel_date: leg.travel_date ?? tickets.find(ticket => ticket.leg_index === index)?.travel_date ?? null,
+            ...(() => {
+                const ticket = tickets.find(ticket => ticket.leg_index === index) ?? (tickets[index]?.leg_index === undefined ? tickets[index] : undefined);
+                const offer = ticket?.booking_offer;
+                return offer?.service_id && offer.selection_token && journeyEligible && raw.qualification_status === "eligible" ? {
+                    booking_template: { command: `itpay services run ${offer.service_id} --input-json <购票.json> --json`, executable: false,
+                        ticket_plan_ref: raw.ticket_plan_ref, leg_index: index,
+                        seat_choices: [{ seat_type: ticket?.seat_type, seat_name: ticket?.seat_name }],
+                        input_example: { selection: { token: offer.selection_token, seat_type: ticket?.seat_type ?? "<该方案席别代码>" },
+                            passengers: ticket?.passengers ?? raw.passenger_count ?? "<真实人数>" },
+                        required_input: ["file", "真实人数", "该方案席别代码"],
+                    },
+                } : { booking_unavailable: "本段没有当前可用的服务端凭据；不能猜代码或例行重查。保留快照，按当前执行的恢复动作处理；过期凭据需真实新验证。" };
+            })(),
+            train_code: leg.train_code ?? null,
+            from_station: leg.from_station ?? null, from_station_code: leg.from_station_code ?? null,
+            departure: leg.departure ?? null,
+            to_station: leg.to_station ?? null, to_station_code: leg.to_station_code ?? null,
+            arrival: leg.arrival ?? null,
+            seats: (seats[index] ?? []).map((seat) => ({ seat_type: seat.seat_type, seat_name: seat.seat_name,
+                availability: seat.availability_text, remaining: seat.inventory_exact === true ? seat.remaining : null,
+                unit_fare_fen: seat.fare_minor, eligible: seat.eligible === true })),
+        })),
+    };
+}
+function railJourneySummary(card, serviceExecutionID, snapshotID) {
     const rides = Array.isArray(card.rides) ? card.rides : [];
     const trains = rides.map((ride) => ride.train_code).filter(Boolean);
     const first = rides[0];
     const last = rides.at(-1);
     const offer = card.representative_offer;
+    const metrics = card.representative_metrics;
     return {
         journey_id: card.journey_id,
+        ...(snapshotID ? (() => { const detail = compactRailJourney(card, serviceExecutionID, snapshotID); return { rides: detail.rides, seats: detail.seats, default_layer: detail.default_layer, detail: detail.detail, ...(detail.booking_template ? { booking_template: detail.booking_template } : {}) }; })() : {}),
         route: (card.route_names?.length ? card.route_names : card.route ?? []).join("→"),
         ...(trains.length ? { trains } : {}),
         ...(first?.departure || last?.arrival ? { time: `${first?.departure ?? ""}–${last?.arrival ?? ""}` } : {}),
         ...(offer ? { price: formatMoney(offer.rail_payable_minor, offer.currency) } : { price: "unknown" }),
+        ...(metrics ? { calculation_scope: {
+                origin: metrics.origin_scope ?? "legacy_unknown", destination: metrics.destination_scope ?? "legacy_unknown",
+                duration_basis: metrics.duration_basis ?? "legacy_unknown", arrival_basis: metrics.arrival_basis ?? "legacy_unknown",
+                cost_basis: metrics.cost_basis ?? "legacy_unknown",
+                duration_minutes: metrics.door_to_door_min ?? null,
+            } } : {}),
         ...(card.decision_role ? { decision_role: card.decision_role } : {}),
         ...(card.explanation?.length ? { explanation: card.explanation } : {}),
         ...(card.reason_codes?.length ? { reason_codes: card.reason_codes } : {}),
@@ -1137,35 +1445,12 @@ function railJourneySummary(card, serviceExecutionID) {
         ...(card.risk_notes?.length ? { risk_notes: card.risk_notes } : {}),
         ...(card.booking_support === "single_leg"
             ? {
-                select: `itpay services action ${serviceExecutionID} --action select_journey --actor-type human --status approved --input journey_id=${card.journey_id} --json`,
+                select_user_chosen: `itpay services action ${serviceExecutionID} --action select_journey --actor-type human --status approved --input journey_id=${card.journey_id} --json`,
                 // Delegated selection under explicit user rules is an agent action —
                 // never record it as a human pick.
                 select_delegated: `itpay services action ${serviceExecutionID} --action select_journey --actor-type agent --status approved --input journey_id=${card.journey_id} --input selection_mode=delegated --json`,
             }
             : {}),
-        ...(card.booking_offer
-            ? {
-                booking_offer: card.booking_offer,
-                booking_template: {
-                    command: `itpay services run ${card.booking_offer.service_id} --input-json <file> --json`,
-                    required_input: ["file"],
-                    executable: false,
-                    seat_choices: (card.representative_offer?.ticket_offers ?? []).map((offer) => ({
-                        seat_type: offer.seat_type,
-                        seat_name: offer.seat_name,
-                    })).filter((seat) => typeof seat.seat_type === "string"),
-                    input_example: {
-                        selection: {
-                            token: card.booking_offer.selection_token,
-                            ...(typeof card.representative_offer?.ticket_offers?.[0]?.seat_type === "string"
-                                ? { seat_type: card.representative_offer.ticket_offers[0].seat_type }
-                                : {}),
-                        },
-                        passengers: card.passengers ?? 1,
-                    },
-                },
-            }
-            : {}),
     };
 }
 // rail.progressive.v2 read projection: committed snapshots only; polling never
@@ -1177,11 +1462,19 @@ function railPlanningEnvelope(model) {
     const expansion = plan.search?.expansion_status ?? "running";
     const counts = plan.search?.counts;
     const journeys = [plan.recommendation, ...(plan.alternatives ?? [])].filter(Boolean);
-    const cards = journeys.map((card) => railJourneySummary(card, se));
+    const hasEligible = typeof counts?.journeys_eligible === "number"
+        ? counts.journeys_eligible > 0 : journeys.length > 0;
+    const changedScopeHint = plan.query_input && !/supplier|provider|dispatch|map|amap|permission/.test(plan.search?.reason ?? "")
+        ? "若原条件锁定车站，可提议仅放宽一端到原站周边；有已核实地点证据才建议具体站，不能说肯定有票。先询问用户是否接受该端范围变化；同意后按new_query_template开新查询，未同意则保持原站。"
+        : /supplier|provider|dispatch|map|amap|permission/.test(plan.search?.reason ?? "")
+            ? "依赖故障按原恢复动作处理，不通过换站掩盖故障。"
+            : "如需改变端点，先取得真实范围变更同意，再按正式铁路指南保留原条件发起新查询。";
+    const cards = journeys.filter(card => card.journey_id !== plan.recommendation?.journey_id)
+        .map((card) => railJourneySummary(card, se, plan.catalog_snapshot_id ?? plan.snapshot_id));
     // Journey counts come from the committed catalog — real combination counts,
     // never seat-row counts. Transfer buckets follow the verified transfer_count.
     const journeyMix = counts && (counts.journeys_total ?? 0) > 0
-        ? `${counts.journeys_total}个铁路组合（直达${counts.journeys_direct ?? 0}/1中转${counts.journeys_one_transfer ?? 0}/2中转${counts.journeys_multi_transfer ?? 0}）`
+        ? `已保存${counts.journeys_total}个具体车次时刻组合，其中${counts.journeys_eligible ?? "未知"}条当前满足铁路资格（直达${counts.journeys_direct ?? 0}/1中转${counts.journeys_one_transfer ?? 0}/2中转${counts.journeys_multi_transfer ?? 0}；这些不是不同站序的数量）`
         : "";
     const pairProgress = counts && (counts.pairs_total ?? 0) > 0
         ? `已检查${counts.pairs_checked ?? 0}/${counts.pairs_total}个附近站对`
@@ -1201,6 +1494,7 @@ function railPlanningEnvelope(model) {
         rail_planning: {
             readiness: plan.readiness,
             query_revision: plan.query_revision,
+            ...(plan.query_input ? { endpoints: plan.query_input.endpoints } : {}),
             snapshot_id: plan.snapshot_id,
             expansion_status: expansion,
             ...(plan.search?.phase ? { phase: plan.search.phase } : {}),
@@ -1214,83 +1508,57 @@ function railPlanningEnvelope(model) {
             ...(plan.search?.poll_after_ms ? { poll_after_ms: plan.search.poll_after_ms } : {}),
             ...(plan.result_not_updated ? { result_not_updated: true } : {}),
             ...(counts ? { counts } : {}),
-            ...(plan.budgets ? { budgets: plan.budgets } : {}),
             ...(plan.coverage ? { coverage: plan.coverage } : {}),
         },
         ...(plan.notices?.length ? { notices: plan.notices } : {}),
-        ...(plan.recommendation ? { recommendation: railJourneySummary(plan.recommendation, se) } : {}),
+        ...(plan.recommendation ? { recommendation: railJourneySummary(plan.recommendation, se, plan.catalog_snapshot_id ?? plan.snapshot_id) } : {}),
         ...(cards.length ? { journeys: cards } : {}),
         ...(plan.snapshot_id ? { full_result: { command: `itpay services read-result ${se} --snapshot ${plan.snapshot_id} --json`, meaning: "读取已保存的完整目录；推荐和journeys仅是摘要" } } : {}),
+        ...(!hasEligible && ["paused", "complete", "expired"].includes(expansion) && plan.query_input && plan.catalog_snapshot_id ? { new_query_template: {
+                command: "itpay services run itpay-rail-smart --input-json <file> --json",
+                executable: false,
+                input_example: { ...plan.query_input, reuse_from: { execution_id: se, snapshot_id: plan.catalog_snapshot_id } },
+                meaning: "先取得真实范围变更同意，再复制完整input_example，仅改获准端。换具体站用station及匹配名称/站码；考虑原站周边用place及原站名，删除station_code，经正常地点解析或使用已核实POI/坐标；只有明确同意整个市才用area及完整行政名，删除POI/坐标/站码。日期、人数、时限及偏好保持；新执行不改变旧查询或订单。引用仅限同owner未过期事实，跨owner拒绝；日期变更不复用旧库存。",
+            } } : {}),
         ...(plan.available_actions?.length ? { available_actions: plan.available_actions } : {}),
     };
     const nextPoll = {
-        command: `itpay services next ${se}${plan.snapshot_id ? ` --since-snapshot ${plan.snapshot_id}` : ""} --json`,
-        reason: "读取同一规划的增量进展（不触发供应商调用）",
+        command: `itpay services next ${se} --timeout 120${plan.snapshot_id ? ` --since-snapshot ${plan.snapshot_id}` : ""} --json`,
+        reason: "仍需更多结果时有界等待同一规划（不触发供应商调用）",
     };
-    // Two-goal interaction contract (spec 03 §2): the local Agent picks compare
-    // or prepare_checkout from full context — the envelope teaches both branches
-    // so a delegated purchase keeps moving and a comparison never buys.
-    const bookable = journeys.find((card) => card.booking_support === "single_leg" && card.booking_offer);
-    const queryResultsInteraction = journeys.length > 0
-        ? {
-            schema_version: "itpay.interaction.v1",
-            stage: "query_results_ready",
-            by_goal: {
-                compare: { action: "present_options", max_options: 3, stop_after_presentation: true },
-                prepare_checkout: {
-                    action: "select_under_user_rules_then_prepare",
-                    recipe: "rail.selected-to-checkout.v1",
-                    requires: ["current_delegation", "eligible_current_selection", "owner_permits_next_step"],
-                    ...(bookable
-                        ? {
-                            steps: [
-                                "按用户明确规则在 journeys 中选择合格者（卡片 select_delegated 提交 agent 委托选择；人类亲自选择用 select）",
-                                `用所选卡片的 booking_template 写 owner-only 临时输入（selection token + 席别 + 人数，不含身份信息），运行 itpay services run itpay-rail-booking --input-json <file> --json`,
-                                "owner 要求聊天 review 时一次合并补齐必要字段，真实确认后提交原 workflow:confirm_booking；不得伪造 accept",
-                                `确认后恢复同一购买执行：itpay services run itpay-rail-booking --execution <实际ID> --json，沿用有界等待与受保护 Checkout`,
-                            ],
-                        }
-                        : { unavailable: "当前结果无可整段购买映射；分别说明各段风险，不得合成原子联程。" }),
-                },
-            },
-        }
-        : undefined;
-    const queryResultsCommunication = journeys.length > 0
-        ? {
-            schema_version: "itpay.communication.v1",
-            status_line: expansion === "paused"
-                ? "首批结果已就绪，扩展搜索已暂停等待用户决定"
-                : "查询结果就绪",
-            recommended_reason: plan.recommendation?.explanation?.[0],
-            human_steps: [
-                "compare：比较首选与最多两个备选后告知取舍",
-                "prepare_checkout：委托仍在时确认所选，继续官方确认页",
-                "姓名、证件、手机号只在受保护 Checkout 页填写",
-            ],
-            next_expectation: "compare：用户选定其一；prepare_checkout：委托仍在时继续到官方确认入口，人完成review与付款",
-            must_convey: [
-                "推荐与备选的时间/费用/便利性取舍",
-                "金额为查询时参考价，下单前须核验",
-                "姓名、证件、手机号只在受保护网页填写",
-            ],
-        }
-        : undefined;
     switch (expansion) {
         case "complete":
+            if (plan.search?.reason === "ground_evidence_required") {
+                return {
+                    status: "awaiting_input", result,
+                    instruction: "已查到铁路班次，但具体地址的接驳或出站证据不足，无法验证到达时限；剩余站对未继续查询，不能说没有车。向用户说明已查范围，并请其补充准确起终点地址或可验证的接驳/出站信息；取得新事实后再按其要求重新规划，不要默认扩大铁路搜索。",
+                    next: null, recovery: [],
+                };
+            }
+            if (!hasEligible && !plan.result_not_updated) {
+                return {
+                    status: "no_result", result,
+                    instruction: `本次已查询范围内没有当前合格线路。原因以 notices、coverage 和 search.reason 为准；缺票、接续失败、依赖故障或未覆盖范围不能改说成没有车。已有铁路事实可从 full_result 读取。${changedScopeHint}后续使用 available_actions 中与用户意图一致的动作。`,
+                    next: null, recovery: [],
+                };
+            }
             return {
                 status: "ready",
                 result,
                 // §7.3: the lead line carries real combination counts bucketed by
                 // verified transfer count — seat rows never inflate the journey count.
-                instruction: `${journeyMix ? `本次共${journeyMix}（席别不重复计数）。` : ""}${plan.search?.reason === "budget_exhausted" ? "本次查询已达到上限，以下是已查到的方案，搜索范围尚未全部核验。" : "本轮规划已完成。"}推荐和journeys是摘要；追问其他车次先读取 full_result 的已保存完整目录。compare：解释首选及最多两个有意义备选的时间/费用/便利性取舍后等待用户选择。prepare_checkout：用户已明确委托按规则选择时，按 interaction.recipe 选合格者并继续到官方确认页，不再次问是否下单；身份、review和最终付款边界仍然生效。乘车人身份信息不在此收集，后续购买走受保护 Checkout。`,
-                next: journeys[0]?.booking_support === "single_leg"
-                    ? { command: railJourneySummary(journeys[0], se).select, reason: "用户在 compare 后选定推荐行程时执行；prepare_checkout 且规则命中时用 select_delegated" }
-                    : null,
-                ...(queryResultsInteraction ? { interaction: queryResultsInteraction } : {}),
-                ...(queryResultsCommunication ? { communication: queryResultsCommunication } : {}),
+                instruction: `${plan.result_not_updated ? "快照没有更新，空增量不表示目录为空。" : ""}${hasEligible && journeys.length === 0 ? `已保存${counts?.journeys_eligible ?? "若干"}条合格线路，执行 full_result.command 读取。` : ""}${journeyMix ? `本次共${journeyMix}（席别不重复计数）。` : ""}${plan.search?.reason === "budget_exhausted" ? "本次查询已达到上限，以下是已查到的方案，搜索范围尚未全部核验。" : "本轮规划已完成。"}推荐和journeys是摘要；追问其他车次先读取 full_result 的已保存完整目录。比较需求说明首选与备选取舍后结束；已有明确代选委托则沿合格线路详情继续，只补缺失的真实同意，身份信息仍在官方页面填写。`,
+                next: null,
                 recovery: [],
             };
         case "paused": {
+            if (plan.search?.reason === "legacy_plan_requires_new_search") {
+                return {
+                    status: "awaiting_input", result,
+                    instruction: "这次规划使用旧算法快照，当前版本已暂停后续查询。已保存的结果仍可读取；若需继续覆盖未查范围，请按原出行条件发起一项新的 Smart 查询。不要把旧快照解释为新版完整结果。",
+                    next: null, recovery: [],
+                };
+            }
             // §7.1 case 1: usable directs committed while ranked scope remains. The
             // message must carry real counts, and expansion is a user choice — the
             // Agent must not treat "expandable" as consent already given.
@@ -1313,7 +1581,7 @@ function railPlanningEnvelope(model) {
             // §7.1 case 3 on a recoverable pause: unverified scope is named with real
             // counts, and the phrasing never implies the whole nearby range ran.
             const partialPause = !directHint && counts && (counts.pairs_total ?? 0) > (counts.pairs_checked ?? 0)
-                ? `目前找到${counts.journeys_total ?? 0}个可选组合；还有${(counts.pairs_total ?? 0) - (counts.pairs_checked ?? 0)}个站对/部分中转路径未核验。以下是已确认结果，不能据此断定没有其它走法。`
+                ? `已保存${counts.journeys_total ?? 0}个具体车次时刻组合，其中${counts.journeys_eligible ?? "未知"}条当前满足铁路资格；还有${(counts.pairs_total ?? 0) - (counts.pairs_checked ?? 0)}个站对/部分中转路径未核验。以下是已确认结果，不能据此断定没有其它走法。`
                 : "";
             // §S5: a dispatch whose outcome is unknown pauses for reconciliation —
             // the message names the state, never rephrases it as a normal pause or
@@ -1331,21 +1599,29 @@ function railPlanningEnvelope(model) {
             return {
                 status: "awaiting_input",
                 result,
-                instruction: `${modelDegradedHint}${failedPairsHint}${directHint}${transferHint}${partialPause}规划已发布首批结果并暂停扩展：展示现有卡片与 available_actions，等待用户意图（${expandHint}）。ready 后 next 为空表示向用户汇报并等待，不是永远没有更多。compare：解释首选及最多两个备选后等待；prepare_checkout：委托仍在且选项合格时按 interaction.recipe 继续到官方确认入口，不再次问是否下单。`,
+                instruction: `${modelDegradedHint}${failedPairsHint}${directHint}${transferHint}${partialPause}${hasEligible ? "规划已发布可用结果并暂停扩展：展示现有卡片与 available_actions" : `当前已查范围尚未找到合格线路，搜索已暂停；未查范围与故障以coverage/notices为准，不是完整无解。${changedScopeHint}展示 available_actions`}，等待用户意图（${expandHint}）。ready 后 next 为空表示向用户汇报并等待，不是永远没有更多。比较需求说明首选与备选取舍后结束；已有代选委托且选项合格时沿详情继续到必要确认与官方入口。`,
                 next: null,
-                ...(queryResultsInteraction ? { interaction: queryResultsInteraction } : {}),
-                ...(queryResultsCommunication ? { communication: queryResultsCommunication } : {}),
                 recovery: [],
             };
         }
         case "failed":
         case "cancelled":
         case "expired": {
+            if (expansion === "failed" && !plan.snapshot_id &&
+                ["address_required", "administrative_area_unresolved", "station_location_evidence_required", "coordinate_identity_unverified", "coordinate_name_mismatch", "endpoint_adcode_name_conflict", "endpoint_station_name_code_conflict", "endpoint_poi_name_conflict"].includes(plan.search?.reason ?? "")) {
+                return {
+                    status: "awaiting_input", result,
+                    instruction: plan.search?.reason === "station_location_evidence_required"
+                        ? "尚未查票。车站身份明确，但 Smart 缺少必要地理证据；这是系统证据缺口，不要求用户换站。若双锁站仅需直达，可使用 Exact。"
+                        : "尚未查票。受影响端点的名称、归属或坐标尚不能一致确认；只补正该端点的真实信息，保留其余条件，不把此次失败说成无车。",
+                    next: null, recovery: [],
+                };
+            }
             // §7.1 case 3: when scope was only partially verified the honest wording
             // is "N confirmed + X pairs unverified" — never the case-2 phrasing that
             // implies the whole nearby range was checked.
             const partial = counts && (counts.pairs_total ?? 0) > (counts.pairs_checked ?? 0)
-                ? `目前找到${counts.journeys_total ?? 0}个可选组合；还有${(counts.pairs_total ?? 0) - (counts.pairs_checked ?? 0)}个站对/部分中转路径未核验。以下是已确认结果，不能据此断定没有其它走法。`
+                ? `已保存${counts.journeys_total ?? 0}个具体车次时刻组合，其中${counts.journeys_eligible ?? "未知"}条当前满足铁路资格；还有${(counts.pairs_total ?? 0) - (counts.pairs_checked ?? 0)}个站对/部分中转路径未核验。以下是已确认结果，不能据此断定没有其它走法。`
                 : "";
             // §S5: a processing failure with a committed catalog is "saved N
             // verified combinations, later expansion/recommend incomplete" — the
@@ -1383,17 +1659,6 @@ function railPlanningEnvelope(model) {
                 result,
                 instruction: `${modelDegradedHint}${manualExpansion}${transferHint}${failedPairsHint}规划进行中：已提交的卡片可先向用户展示比较；稍后按 next 增量轮询同一执行（since-snapshot 命中时负载会被压缩，但阶段与计数仍返回最新值）。不要重新发起查询。`,
                 next: nextPoll,
-                communication: {
-                    schema_version: "itpay.communication.v1",
-                    status_line: transferSearching && !manualExpansion
-                        ? "直达范围暂未找到可用方案，中转组合仍在搜索"
-                        : "规划进行中，已确认的方案可先向用户展示",
-                    next_expectation: "按 next 增量轮询同一执行；不重新发起查询",
-                    must_convey: [
-                        "当前是进行中的部分结果，不代表最终答复",
-                        ...(failedPairsHint ? ["部分站对尚未查明，不能说'没有车'"] : []),
-                    ],
-                },
                 recovery: [],
             };
         }
@@ -1443,26 +1708,9 @@ function servicesNextEnvelope(model) {
     const currentDelivery = model.current_delivery ?? model.delivery_bindings.at(-1);
     const lockedRefund = model.refunds.find((refund) => refund.access_locked);
     if (lockedRefund) {
-        const terminal = lockedRefund.status === "succeeded";
-        return {
-            status: "delivery_locked",
-            result: {
-                service_execution_id: execution.service_execution_id,
-                access_locked: true,
-                refund: {
-                    refund_request_id: lockedRefund.refund_request_id,
-                    status: lockedRefund.status,
-                },
-            },
-            instruction: terminal
-                ? "告诉用户退款已由 ItPay 确认成功，原交付永久关闭。Agent 停止读取和跟踪，不再创建授权。"
-                : "告诉用户退款仍在处理，原交付已按政策冻结。然后读取同一退款的权威状态；Agent 不读取交付、不创建授权或重复申请。",
-            next: terminal ? null : {
-                command: `itpay refund get ${lockedRefund.refund_request_id} --json`,
-                reason: "读取退款权威状态",
-            },
-            recovery: [],
-        };
+        const refundState = refundStateEnvelope(lockedRefund, "delivery_locked");
+        return { ...refundState, result: { ...refundState.result, service_execution_id: execution.service_execution_id, refund: { refund_request_id: lockedRefund.refund_request_id, status: lockedRefund.status, ...(lockedRefund.failure_class ? { failure_class: lockedRefund.failure_class } : {}) } },
+            next: refundState.next ? { command: `itpay refund get ${lockedRefund.refund_request_id} --json`, reason: "读取同一退款权威状态" } : null };
     }
     const latestRun = model.execution_requests?.filter((request) => request.execution_kind === "service.execution.run").at(-1);
     if (latestRun && ["pending", "started"].includes(latestRun.status)) {
@@ -1497,10 +1745,48 @@ function servicesNextEnvelope(model) {
     }
     if (model.workflow_entry && !["completed", "delivery"].includes(model.workflow?.status ?? "")) {
         const id = execution.service_execution_id;
+        const workflowReason = model.workflow?.failure?.reason_code ?? model.workflow?.error_code;
         const paymentVerified = model.payment_bindings.some((binding) => binding.status === "payment_verified") || model.checkout_bindings.some((binding) => binding.status === "payment_verified");
         const state = model.workflow?.status === "payment" && paymentVerified ? "running" : model.workflow?.status ?? "input_required";
-        if (state === "failed" && ["login_required", "rate_limited"].includes(model.workflow?.error_code ?? "")) {
-            const login = model.workflow?.error_code === "login_required";
+        if (["quota_paused", "failed"].includes(state) && workflowReason !== "area_scope_too_broad" && (model.workflow?.dependency ||
+            /^amap_/.test(workflowReason ?? ""))) {
+            const dependency = model.workflow?.dependency;
+            const resumable = state === "quota_paused" && dependency?.retryable === true;
+            return {
+                status: "dependency_unavailable",
+                result: { service_execution_id: id, service_id: execution.service_id, reason: workflowReason, failure: model.workflow?.failure, affected_endpoint: model.workflow?.failure?.endpoint ?? dependency?.endpoint, ...(dependency ? { dependency } : {}) },
+                instruction: resumable
+                    ? "地图服务暂时限流。保留原条件及已解析端点；到 retry_at 后执行下一步，继续同一任务，不重新提交地点。"
+                    : "地图服务本轮未完成解析，这是外部依赖故障，不要求用户换地址或自行找坐标。有界尝试已结束；保留原条件及已有结果，交由服务维护方处理该错误。",
+                next: resumable ? { command: `itpay services run ${execution.service_id} --execution ${id} --json`, reason: "等待所示恢复时间后继续同一执行" } : null,
+                recovery: [],
+            };
+        }
+        if (state === "failed" && workflowReason === "area_scope_too_broad") {
+            return { status: "awaiting_input", result: { service_execution_id: id, reason: "area_scope_too_broad", failure: model.workflow?.failure, affected_endpoint: model.workflow?.failure?.endpoint ?? model.workflow?.dependency?.endpoint, input_template: { endpoints: { [model.workflow?.dependency?.endpoint ?? "<受影响侧>"]: { kind: "area", text: "<市县镇完整名称>" } } } },
+                instruction: "区域范围是省或国家。只补充受影响端点的市、县或镇；保留另一端、日期与用户约束。修正模板：endpoints.<受影响侧>={kind:area,text:<市县镇完整名称>}。",
+                next: null, recovery: [] };
+        }
+        if (state === "failed" && ["address_required", "administrative_area_unresolved", "station_location_evidence_required", "coordinate_identity_unverified"].includes(workflowReason ?? "")) {
+            const code = workflowReason;
+            return {
+                status: "awaiting_input",
+                result: { service_execution_id: id, service_id: execution.service_id, reason: code, affected_endpoint: model.workflow?.failure?.endpoint, failure: model.workflow?.failure,
+                    ...(["address_required", "administrative_area_unresolved"].includes(code) ? { new_query_template: {
+                            command: `itpay services run ${execution.service_id} --input-json <补全原始需求.json> --json`, executable: false,
+                            required_input: ["仅补受影响端点", "原始日期人数时限偏好"],
+                            instruction: "原执行输入已锁定；按原需求保留另一端与所有约束，只补缺失信息后提交新输入，不在旧执行伪造修改。"
+                        } } : {}) },
+                instruction: code === "station_location_evidence_required"
+                    ? "尚未查票。车站身份已知，Smart 缺少车站坐标证据；请说明此系统缺口，不要求用户换站。双锁站直达可另用 Exact。"
+                    : code === "coordinate_identity_unverified"
+                        ? "尚未查票。名称与提交坐标缺少一致证据；请核实受影响端点的准确地点，保留其余出行条件。"
+                        : "尚未查票。地点缺少必要地址或行政归属；只请用户补充受影响端点，保留另一端及原条件。",
+                next: null, recovery: [],
+            };
+        }
+        if (state === "failed" && ["login_required", "rate_limited"].includes(workflowReason ?? "")) {
+            const login = workflowReason === "login_required";
             return {
                 status: login ? "login_required" : "rate_limited",
                 result: { service_execution_id: id, service_id: execution.service_id },
@@ -1538,29 +1824,42 @@ function servicesNextEnvelope(model) {
                     return {
                         side,
                         status: place?.resolution_status,
+                        ...(place?.resolution_reason ? { reason: place.resolution_reason } : {}),
                         ...(place?.resolution_status === "resolved"
-                            ? { resolved_place: { name: name(place), location: place.location } }
+                            ? { resolved_place: { name: name(place), address: place.formatted_address, location: place.location } }
                             : {}),
                         ...(candidates.length
-                            ? { candidates: candidates.slice(0, 5).map((item) => ({ name: name(item), location: item.location })) }
+                            ? { candidates: candidates.slice(0, 3).map((item, index) => ({ id: item.id ?? `${side}_${index + 1}`, name: name(item), address: item.formatted_address, type: item.poi_type ?? item.type, location: item.location })) }
                             : {}),
                     };
                 });
                 return {
                     status: "confirmation_required",
-                    result: { service_execution_id: id, service_id: execution.service_id, human_action: action,
-                        required_fields: requiredFields, sides },
-                    instruction: "向用户展示 sides 中 status=needs_confirmation 一端的候选（名称+坐标），请用户选定后按 required_fields 逐项各传一个 --input：名称取候选 name，坐标取候选 location 的 [lng,lat]；已 resolved 的一端把其 resolved_place 原样填入。继续同一执行，不重新查询；这一步不是购买确认。",
+                    result: { service_execution_id: id, service_id: execution.service_id,
+                        human_action: { action_type: action.action_type, input_schema: action.input_schema },
+                        required_fields: requiredFields, sides,
+                        ...(sides.some(side => side.status !== "resolved" && !side.candidates?.length && ["ADDRESS_REQUIRED", "ADMINISTRATIVE_AREA_UNRESOLVED"].includes(side.reason ?? "")) ? {
+                            new_query_template: { command: `itpay services run ${execution.service_id} --input-json <补全原始需求.json> --json`, executable: false,
+                                required_input: ["补缺失端点", "保留原始日期人数时限偏好及已确认端点"], instruction: "原执行锁定输入；补全原需求后用新查询，不提交不存在的候选。" },
+                        } : {}) },
+                    instruction: sides.some(side => side.status !== "resolved" && !side.candidates?.length)
+                        ? locationConfirmationEnvelope(id, "", {}, { endpoints: sides.filter(side => side.status !== "resolved") }).instruction
+                        : requiredFields.includes("choices")
+                            ? "尚未查票。仅向用户展示有真实歧义端点的候选编号、名称、行政地址与类型（内部 id 仅用于回填，不展示给人）；用户选定后，把各未解析端点的候选 id 放入 choices 对象，继续同一执行。已解析端点无需再选；不得替用户决定，也不是购买确认。"
+                            : "向用户展示有歧义一端的候选；按 required_fields 填写真实选择，已解析一端保留原值。继续同一执行；这不是购买确认。",
                     next: null,
-                    interaction: {
-                        schema_version: "itpay.interaction.v1",
-                        stage: "location_confirmation_required",
-                        input_template: {
-                            command: `itpay services action ${id} --action ${action.action_type} --actor-type human --status approved${requiredFields.map((field) => ` --input ${field}=<值>`).join("")} --json`,
-                            required_input: requiredFields,
-                            executable: false,
-                        },
-                    },
+                    ...(sides.some(side => side.status !== "resolved" && !side.candidates?.length) ? {} : { interaction: {
+                            schema_version: "itpay.interaction.v1",
+                            stage: "location_confirmation_required",
+                            input_template: {
+                                command: requiredFields.includes("choices")
+                                    ? `itpay services action ${id} --action ${action.action_type} --actor-type human --status approved --input-json <地点确认.json> --json`
+                                    : `itpay services action ${id} --action ${action.action_type} --actor-type human --status approved${requiredFields.map((field) => ` --input ${field}=<值>`).join("")} --json`,
+                                input: { choices: Object.fromEntries(sides.filter(side => side.candidates?.length).map(side => [side.side, "<所选候选id>"])) },
+                                required_input: requiredFields,
+                                executable: false,
+                            },
+                        } }),
                     recovery: [],
                 };
             }
@@ -1576,24 +1875,22 @@ function servicesNextEnvelope(model) {
                     : undefined;
                 return {
                     status: "booking_review_required",
-                    result: { service_execution_id: id, service_id: execution.service_id, human_action: action,
-                        required_fields: requiredFields,
+                    result: { service_execution_id: id, service_id: execution.service_id, review,
+                        action_type: action.action_type, required_fields: requiredFields,
                         ...(requirementsRemaining ? { requirements_remaining: requirementsRemaining } : {}) },
                     ...(reviewURL ? { handoff: { url: reviewURL, kind: "booking_review" } } : {}),
-                    instruction: reviewURL
-                        ? "已在 handoff.url 提供官方行程确认页，请用户在该页核对行程、席别与座位偏好并确认；页面打开请求不代表用户已确认。该页失效或用户更愿在对话中确认时，仍可按下述 input_template 一次合并提交。乘客姓名/证件等身份信息不在此提交，仍走受保护 Checkout 页。"
-                        : "向用户展示 context.review 中的行程（legs）与可选席别/座位偏好词表（seat_options），并明确告知：座位偏好仅为请求、不保证分配（对应 notice_version 文案须经用户同意）。这是购买前的合并确认：把乘客人数、席别与每位乘客的座位偏好一次问清，然后按 required_fields 组装完整 JSON 对象，经 --input-json <file> 提交——draft_revision 必须等于服务端当前值，被拒绝（booking_review_changed）时重新读取后重试。未得真实确认不得提交，不能暗设 accept_non_guaranteed。乘客姓名/证件等身份信息不在此提交，仍走受保护 Checkout 页。",
+                    instruction: `${reviewURL ? "官方确认页见 handoff.url，打开不等于确认；沿用已知人数和席别。" : "当前草稿见 review。"} 对照对话只补缺失选择或真实条款同意；无字母偏好自动分配，不默认问字母。仅代码修正且车次、实际席别、人数、价格及条款不变，沿用已有明确确认；实质变化只核对变化。提交当前 draft_revision/notice_version 及必要字段，未得真实同意不能填 accept_non_guaranteed；座位请求不保证分配。身份信息只在官方 Checkout 页填写。`,
                     next: null,
                     interaction: {
                         schema_version: "itpay.interaction.v1",
                         stage: "booking_review_required",
                         input_template: {
                             command: `itpay services action ${id} --action ${action.action_type} --actor-type human --status approved --input-json <file> --json`,
-                            required_input: requiredFields.length > 0 ? requiredFields : ["file"],
+                            required_input: ["file", ...requiredFields],
                             executable: false,
                         },
                     },
-                    recovery: [{ command: `itpay services next ${id} --json`, reason: "重新读取当前 draft_revision 后重试" }],
+                    recovery: [],
                 };
             }
             return {
@@ -1626,8 +1923,8 @@ function servicesNextEnvelope(model) {
                 executable: false,
             }
             : undefined;
-        const guidance = railServiceGuidance(execution.service_id);
-        const failedStep = recovery ? failedWorkflowStep(model.workflow?.steps, model.workflow?.error_code) : undefined;
+        const guidance = railServiceGuidance(execution.service_id, model.workflow_entry?.input_schema);
+        const failedStep = recovery ? model.workflow?.failure?.step_id : undefined;
         const failedStepGuidance = failedStep ? WORKFLOW_STEP_GUIDANCE[failedStep] : undefined;
         const failedInvocation = recovery
             ? [...model.provider_invocations].reverse().find((item) => typeof item.status === "string" && item.status.startsWith("failed"))
@@ -1640,13 +1937,14 @@ function servicesNextEnvelope(model) {
             quote_seat_unavailable: "所选席别当前无足够余票；告知用户并由其决定是否换方案。",
             quote_refresh_expired: "实时报价过程超时；保留原选择，不把旧价当可付款价格。",
         }[providerErrorCode ?? ""] : undefined;
+        const failureCode = model.workflow?.failure?.reason_code ?? providerErrorCode ?? model.workflow?.error_code;
         const failedInstruction = recovery
             ? quoteFailure
                 ? quoteFailure
                 : failedStepGuidance
-                    ? `执行在「${failedStepGuidance.meaning}」步失败：${failedStepGuidance.hint}。本执行已终止不能续用；先核对原因，不要盲目重放。`
+                    ? `执行在「${failedStepGuidance.meaning}」步失败${failureCode ? `（错误码：${failureCode}）` : ""}：${failedStepGuidance.hint}。先核对原因和当前执行状态，不要盲目重放。`
                     : state === "failed"
-                        ? `执行已失败${failedStep ? `（失败步骤：${failedStep}）` : ""}且不可续用；修正输入后用同一服务新建执行重试。`
+                        ? `执行已失败${failureCode ? `（错误码：${failureCode}）` : ""}且不可续用；核对服务端原因、订单与付款事实后再决定下一步。`
                         : "执行未完成，请按步骤错误处理；不要重建执行或重复调用。"
             : undefined;
         return {
@@ -1654,13 +1952,15 @@ function servicesNextEnvelope(model) {
             result: {
                 service_execution_id: id,
                 service_id: execution.service_id,
-                workflow: model.workflow,
+                workflow_state: state,
+                ...(model.workflow ? { current_step: model.workflow.current_step, workflow_revision: model.workflow.revision } : {}),
+                ...(model.workflow?.failure ? { failure: model.workflow.failure } : {}),
                 ...(state === "input_required" ? { input_schema: model.workflow_entry.input_schema } : {}),
                 ...(guidance && state === "input_required" ? { guidance } : {}),
                 ...(failedStep ? { failed_step: failedStep, ...(failedStepGuidance ? { failed_step_meaning: failedStepGuidance.meaning } : {}) } : {}),
                 ...(providerErrorCode ? { provider_error_code: providerErrorCode } : {}),
                 ...(providerErrorCode && !quoteFailure ? { diagnostic_code: providerErrorCode } : {}),
-                ...(recovery ? { retryable: state === "failed" } : {}),
+                ...(recovery ? { retryable: false } : {}),
             },
             instruction: failedInstruction
                 ?? (state === "payment"
@@ -1670,7 +1970,7 @@ function servicesNextEnvelope(model) {
                     : guidance
                         ? "按 result.guidance 的字段契约填写输入后继续同一服务执行；不要臆造字段名。"
                         : "继续读取同一执行；缺少输入时按服务声明补齐。"),
-            next: recovery ? null : { command, reason: "继续当前流程" },
+            next: recovery || inputTemplate ? null : { command, reason: "继续当前流程" },
             ...(inputTemplate || (state === "payment" && model.workflow?.human_action?.context?.review) ? {
                 interaction: {
                     schema_version: "itpay.interaction.v1",
@@ -1685,11 +1985,8 @@ function servicesNextEnvelope(model) {
                     } : {}),
                 },
             } : {}),
-            recovery: recovery && state === "failed" && !quoteFailure
-                ? [
-                    { command: `itpay services start ${execution.service_id} --json`, reason: "修正输入后重新发起（本执行已终止不能续用）" },
-                    ...(guidance ? [{ command: "itpay docs show rail-booking --json", reason: "查看本服务输入字段契约与示例" }] : []),
-                ]
+            recovery: recovery && state === "failed"
+                ? [{ command: `itpay services get ${id} --json`, reason: "核对本执行的错误、结果和付款事实" }]
                 : [],
         };
     }
@@ -1706,6 +2003,26 @@ function servicesNextEnvelope(model) {
     }
     const delivery = currentDelivery;
     const deliveryMode = serviceDeliveryMode(model);
+    if (execution.service_id === "itpay-rail-exact" && currentItems.length > 0) {
+        const item = currentItems[0];
+        const container = (item.safe_payload?.result ?? item.safe_payload);
+        const total = typeof container?.catalog_total === "number" ? container.catalog_total :
+            Array.isArray(container?.candidates) ? container.candidates.length : 0;
+        return {
+            status: total > 0 ? "result_ready" : "no_result",
+            result: { service_execution_id: execution.service_execution_id, scope: "station_pair",
+                resolved_station_pair: container?.resolved_station_pair, total,
+                result_item_id: item.service_capability_result_item_id,
+                trains: Array.isArray(container?.candidates) ? container.candidates.slice(0, 3).map((value, index) => exactTrainRow(value, execution.service_execution_id, item.service_capability_result_item_id, index)) : [],
+                ...(exactSmartTemplate(container?.resolved_station_pair, execution.service_execution_id, item.service_capability_result_item_id)
+                    ? { smart_template: exactSmartTemplate(container?.resolved_station_pair, execution.service_execution_id, item.service_capability_result_item_id) } : {}) },
+            instruction: total > 0
+                ? "直达站对结果已保存。执行 next.command 一次读取紧凑车次行，按用户条件筛选；若只需比较，答复后结束；已有购票委托则读取所选行详情。"
+                : "这一已解析站对返回 0 条；不代表全城无车。若原需求需要更广覆盖，可核验另一可信站对或 Smart。",
+            next: { command: `itpay services read-result ${execution.service_execution_id} --json`, reason: "读取这一保存站对的紧凑分页；按返回的续页覆盖所需范围" },
+            recovery: [],
+        };
+    }
     const candidateSelection = model.allowed_actions?.find((action) => action.type === "select_candidate");
     if (candidateSelection && currentItems.length > 0) {
         const paidCapability = delivery?.capability_id
@@ -1918,21 +2235,7 @@ function grantedResultEnvelope(response, orderID) {
     };
 }
 function servicesNextPlainResult(result) {
-    const lines = [];
-    for (const [key, value] of Object.entries(result)) {
-        if (key === "items" && Array.isArray(value)) {
-            lines.push("items:");
-            for (const item of value) {
-                lines.push(`  ${item.rank}. ${item.title}`);
-                for (const [field, fieldValue] of Object.entries(item.safe_payload)) {
-                    lines.push(`     ${field}: ${typeof fieldValue === "string" ? fieldValue : JSON.stringify(fieldValue)}`);
-                }
-            }
-            continue;
-        }
-        lines.push(`${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`);
-    }
-    return lines;
+    return plainValueLines(result);
 }
 export async function runServicesEvents(backend, serviceExecutionID, options = {}) {
     const afterSequence = options.afterSequence ?? 0;
@@ -1963,11 +2266,8 @@ export async function runServicesEvents(backend, serviceExecutionID, options = {
             returned_count: events.length,
             events,
         },
-        instruction: "事件仅用于诊断；不要从事件重放业务步骤，回到 services next 获取当前动作。",
-        next: {
-            command: `itpay services next ${serviceExecutionID} --json`,
-            reason: "恢复正常服务流程",
-        },
+        instruction: "这是已保存的诊断事件；事件不代表车票结果，也不授权重放业务步骤。已读完所需诊断时停止；实际任务沿先前返回的当前动作继续。",
+        next: null,
         recovery: events.length === limit && events.length > 0
             ? [{
                     command: `itpay services events ${serviceExecutionID} --after-sequence ${events.at(-1).sequence} --limit ${limit} --json`,
@@ -2043,7 +2343,7 @@ function buildServicesCheckoutEnvelope(response, checkoutURL, plan, agentType, t
             service_execution_id: response.binding.service_execution_id,
             checkout_id: checkout.checkout.checkout_id,
             capability_id: checkoutCapabilityID(response),
-            locked_input: response.locked_input,
+            items: plan.orderItems ?? [],
             amount,
             ...(checkout.checkout.expires_at ? {
                 // The shared server-owned payable deadline D: refreshing the page or
@@ -2141,10 +2441,7 @@ export async function runServicesRun(backend, config, serviceID, input, options
         const paid = () => model.payment_bindings.some((binding) => binding.status === "payment_verified") || model.checkout_bindings.some((binding) => binding.status === "payment_verified");
         // A planning projection can exist before any usable result or user action.
         // Keep the existing bounded wait until there is something to hand over.
-        const planningDeliverable = () => Boolean(model.rail_planning && (model.rail_planning.recommendation || model.rail_planning.alternatives?.length ||
-            ["complete", "paused", "failed", "cancelled", "expired"].includes(model.rail_planning.search?.expansion_status ?? "") ||
-            model.rail_planning.available_actions?.some((action) => ["select_journey", "expand_search"].includes(action.type))));
-        while ((["queued", "running", "delivery"].includes(model.workflow?.status ?? "") || (model.workflow?.status === "payment" && paid())) && !model.current_delivery && !planningDeliverable() && Date.now() < until) {
+        while ((["queued", "running", "delivery"].includes(model.workflow?.status ?? "") || (model.workflow?.status === "payment" && paid())) && shouldWaitForServiceResult(model) && Date.now() < until) {
             await sleep(options.pollIntervalMS ?? 1500);
             model = await backend.getServiceExecution(id);
         }
@@ -2168,11 +2465,11 @@ export async function runServicesRun(backend, config, serviceID, input, options
         }
         if (cause instanceof CommandContractError || cause instanceof HttpError || cause instanceof DeviceLockBusyError || cause instanceof DeviceStateError)
             throw cause;
-        if (cause instanceof HttpTransportError && !id) {
-            throw new CommandContractError("workflow_start_outcome_unknown", cause.message, "创建服务执行时没有收到完整响应。先查询当前身份可见的执行；不要直接重跑并创建替代执行。", [{ command: "itpay services list --json", reason: "查找可能已经创建的服务执行" }]);
+        if (!id) {
+            throw new CommandContractError("workflow_start_outcome_unknown", cause instanceof Error ? cause.message : "service creation outcome unknown", "创建服务执行时没有收到完整响应。先查询当前身份可见的执行；不要直接重跑并创建替代执行。", [{ command: "itpay services list --json", reason: "查找可能已经创建的服务执行" }]);
         }
         if (cause instanceof HttpTransportError)
-            throw cause;
-        throw new CommandContractError("workflow_run_failed", cause instanceof Error ? cause.message : "workflow run failed", "保留当前执行并按错误处理，不要重复创建服务执行。", [{ command: `itpay services run ${serviceID} --execution ${id} --json`, reason: "恢复同一执行" }]);
+            throw new CommandContractError("workflow_outcome_unknown", cause.message, "未收到完整响应；只读同一执行的权威事实，不重放写操作或创建替代执行。", [{ command: `itpay services next ${id} --json`, reason: "核对同一执行" }]);
+        throw new CommandContractError("workflow_run_failed", cause instanceof Error ? cause.message : "workflow run failed", "保留当前执行并按错误处理，不要重复创建服务执行。", [{ command: `itpay services next ${id} --json`, reason: "读取同一执行的当前事实与恢复动作" }]);
     }
 }