@itpay/cli 2.1.40 → 2.1.41

package/dist/src/services/rail/query.js

@@ -1,71 +0,0 @@
-export function locationConfirmationEnvelope(executionID, capabilityID, input, confirmation) {
-    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"
-                    ? "尚未查票。提交的地点名称和坐标尚未得到一致证据；请核实该端点的真实名称或位置，保留另一端，不要把坐标声明当成人工确认。"
-                    : "尚未查票。地点证据不足；说明返回的原因与受影响端，先补真实证据，不改kind绕过、不把外部故障当用户歧义。当前无候选确认或完整新查询模板则停止。"
-        : "尚未查票。仅向用户确认真实地点歧义，展示候选名称、地址和高德链接。具体住宅仍是目的地，附近车站只作候选；不得把选地点改成锁车站。用户选择后保留原输入，回到同一服务。";
-    return {
-        status: "location_confirmation_required",
-        result: { service_execution_id: executionID, query: input, location_confirmation: confirmation },
-        instruction,
-        next: null,
-        ...(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} --input-json <地点确认.json> --json`,
-                    input: { ...input, location_confirmation: { plan_id: confirmation.plan_id, token: confirmation.token, choices } },
-                    required_input: ["choices"],
-                    executable: false,
-                },
-            },
-        } : {}),
-        recovery: [],
-    };
-}
-export function exactSmartTemplate(pair, executionID, resultItemID, publicBinding) {
-    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;
-    const input = { endpoints: { origin: { text: "<原始出发行政范围/地点/用户指定站>" }, destination: { text: "<原始到达行政范围/地点/用户指定站>" } }, travel_date: value.travel_date, passengers: "<真实人数>", reuse_from: { execution_id: executionID, ...(resultItemID ? { result_item_id: resultItemID } : {}) } };
-    return { executable: false, verified_station_pair: value,
-        instruction: "已核验站对是复用事实，不是完整用户查询。仅用户明确锁站才填 kind=station；区域/地点从原始需求填回，保留真实人数、时限和偏好，不默认为一人。",
-        command: publicBinding ? `itpay services run ${publicBinding.public_service_id} --operation query_smart --input-json <原始需求.json> --json` : "itpay services run itpay-rail-smart --input-json <原始需求.json> --json",
-        required_input: ["endpoints", "passengers", "用户时限与偏好"],
-        input_example: publicBinding ? { input } : input };
-}
-export 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: "读取此车次席别与服务端购买模板" } };
-}
-export 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 })),
-    };
-}

package/dist/src/services/rail/readers.js

@@ -1,107 +0,0 @@
-import { writeCommandEnvelope, CommandContractError } from "../shared/envelope.js";
-import { writeSavedRailPage } from "./pagination.js";
-import { exactSmartTemplate, exactTrainRow } from "./query.js";
-import { compactRailJourney, compactRailTicketPlan } from "./results.js";
-export function renderExactRows(serviceExecutionID, itemID, binding, resolvedStationPair, rows, total, nextOffset, startOffset, limit, options) {
-    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, itemID, binding)
-                ? { smart_template: exactSmartTemplate(resolvedStationPair, serviceExecutionID, itemID, binding) } : {}),
-            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: "读取同一保存结果的下一页" }));
-}
-export function renderJourneyPage(serviceExecutionID, planID, queryRevision, total, qualificationCounts, limit, truncatedReason, offset, nextOffset, journeys, options) {
-    writeSavedRailPage({
-        status: "ready",
-        result: {
-            service_execution_id: serviceExecutionID,
-            plan_id: planID,
-            snapshot_id: options.snapshot,
-            query_revision: queryRevision,
-            total,
-            qualification_counts: qualificationCounts,
-            requested_limit: limit,
-            truncated_reason: truncatedReason,
-            offset,
-            count: journeys.length,
-            next_offset: nextOffset,
-            journeys,
-        },
-        instruction: qualificationCounts === undefined
-            ? "此历史快照没有完整资格计数；线路仅供核对铁路事实，不能据此认定可购买。沿同快照 detail.command 查看详情。"
-            : qualificationCounts.eligible === 0
-                ? `查到 ${total} 个时刻组合，当前 0 条满足购票资格。请读取诊断线路的 detail.command 查看具体原因；修改条件须依据用户意愿。`
-                : `已查范围内合格时刻组合 ${qualificationCounts.eligible}；本次展示 ${journeys.length} 个方案（首屏优先既有主方案/代表，计数不是中转通道数）。最快/低价须按对应方案和比较范围说明；未全范围排序只能说已读方案中。更多条件优先同执行 refine_preferences 复用已存事实；页大小受字节预算限制，每页可能不满，只沿 next_offset/next 读取，不计算偏移或无收益并行，不随机翻页、不无条件读完组合。未知费用不能当免费；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 } : {}),
-        all: Boolean(options.all),
-    }, "journeys", offset, next => ({ command: `itpay services read-result ${serviceExecutionID} --snapshot ${options.snapshot} --offset ${next} --limit ${limit} --json`, reason: "仅当前问题还需未读线路时继续；已有合格完整结果可答复或按委托继续" }));
-}
-export function renderJourneyDetail(serviceExecutionID, detail, options) {
-    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: {
-            service_execution_id: serviceExecutionID,
-            plan_id: detail.plan_id,
-            snapshot_id: detail.snapshot_id,
-            query_revision: detail.query_revision,
-            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: "同一线路的完整车次与席别方案。已有所需席别和有效凭据即可按真实委托继续；只需比较则答复并停止，需要其他席别才读下一页。使用所选 ticket_plan 的整程 booking_template：一个 booking、统一报价、一个官方付款入口，各段分别出票，无联合锁票或接续保证。未返回整程模板时不能拼不同方案的腿或退回逐腿付款，按同一执行恢复。身份资料只在受保护 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 } : {}),
-    });
-}
-export function exactSavedPage(response, executionID, itemID, offset) {
-    const container = (response.page.result ?? response.page);
-    const candidates = Array.isArray(container.candidates) ? container.candidates : [];
-    const page = (container.catalog_page ?? {});
-    return { rows: candidates.map((value, index) => exactTrainRow(value, executionID, itemID, offset + index)), resolvedStationPair: container.resolved_station_pair, total: typeof container.catalog_total === "number" ? container.catalog_total : undefined, nextOffset: typeof page.next_offset === "number" && page.next_offset > offset ? page.next_offset : null };
-}
-export function savedJourneyPage(response, executionID, snapshotID, offset) {
-    const container = (response.page.result ?? response.page);
-    const page = container.journey_page;
-    const rows = Array.isArray(container.journeys) ? container.journeys : [];
-    const next = page?.next_offset;
-    if (typeof next === "number" && next <= offset)
-        throw new Error("saved page cursor did not advance");
-    return { total: typeof page?.total === "number" ? page.total : rows.length, qualificationCounts: page?.qualification_counts, truncatedReason: page?.truncated_reason, rows: rows.map(card => compactRailJourney(card, executionID, snapshotID)), nextOffset: typeof next === "number" ? next : null };
-}
-export function railSavedReadKind(execution) { return execution.service_id === "itpay-rail-exact" ? "exact" : execution.service_id === "itpay-rail-booking" ? "booking" : "planning"; }
-export function renderExactNoResult(preview, executionID, binding, options) {
-    const template = exactSmartTemplate(preview?.resolved_station_pair, executionID, undefined, binding);
-    if (!template || preview?.catalog_total !== 0)
-        return false;
-    writeCommandEnvelope({ status: "no_result", result: { service_execution_id: executionID, 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 true;
-}

package/dist/src/services/rail/reading.js

@@ -1,125 +0,0 @@
-import { renderExactRows, renderJourneyPage, renderJourneyDetail, exactSavedPage, savedJourneyPage, railSavedReadKind, renderExactNoResult } from "./readers.js";
-import { HttpError } from "../../client/http.js";
-import { decodeRailCatalogJourneys } from "./catalog.js";
-import { publicPurchaseTemplate } from "../shared/platform.js";
-import { CommandContractError } from "../shared/envelope.js";
-export async function readSavedResult(backend, model, serviceExecutionID, options) {
-    if (!options.snapshot && !options.journey) {
-        if (railSavedReadKind(model.execution) === "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;
-                if (renderExactNoResult(preview, serviceExecutionID, model.execution.public_binding, options))
-                    return "handled";
-                return "state";
-            }
-            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", "offset 必须是非负整数，limit 为 1–20。保留同一已保存结果，按当前模板修正技术参数；不重新查询。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: `itpay services read-result ${serviceExecutionID} --offset <offset> --limit 20 --json`, required_input: ["offset"], executable: false } });
-            }
-            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 page = exactSavedPage(response, serviceExecutionID, item.service_capability_result_item_id, offset);
-                resolvedStationPair ??= page.resolvedStationPair;
-                rows.push(...page.rows);
-                total = page.total ?? Math.max(total, rows.length);
-                nextOffset = page.nextOffset;
-                offset = nextOffset ?? offset;
-            } while (options.all && nextOffset !== null);
-            renderExactRows(serviceExecutionID, item.service_capability_result_item_id, model.execution.public_binding, resolvedStationPair, rows, total, nextOffset, startOffset, limit, options);
-            return "handled";
-        }
-    }
-    // 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 catalog read: --snapshot returns compact rows for the
-    // committed rail.catalog.v3; journey detail remains available separately.
-    if (options.snapshot && !options.journey) {
-        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", "offset 必须是非负整数，limit 为 1–20。保留同一快照，按当前模板修正技术参数；不重新查询。", [], { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: { command: `itpay services read-result ${serviceExecutionID} --snapshot ${options.snapshot} --offset <offset> --limit 20 --json`, required_input: ["offset"], executable: false } });
-        }
-        const journeys = [];
-        let nextOffset = offset;
-        let total = 0;
-        let truncatedReason = null;
-        let qualificationCounts;
-        let planID;
-        let queryRevision;
-        while (nextOffset !== null) {
-            let response;
-            try {
-                response = await backend.getServiceExecutionResultItemPage(serviceExecutionID, options.snapshot, nextOffset, limit, "summary");
-            }
-            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 page = savedJourneyPage(response, serviceExecutionID, options.snapshot, nextOffset);
-            total = page.total;
-            qualificationCounts = page.qualificationCounts ?? qualificationCounts;
-            truncatedReason = page.truncatedReason ?? truncatedReason;
-            journeys.push(...page.rows);
-            nextOffset = page.nextOffset;
-            if (!options.all)
-                break;
-        }
-        renderJourneyPage(serviceExecutionID, planID, queryRevision, total, qualificationCounts, limit, truncatedReason, offset, nextOffset, journeys, options);
-        return "handled";
-    }
-    if (options.journey) {
-        let detail = await backend.getRailJourneyDetail(serviceExecutionID, options.journey, options.snapshot);
-        const validate = () => {
-            if (!model.execution.public_binding || detail.journey.qualification_status !== "eligible")
-                return;
-            for (const plan of detail.journey.ticket_plans ?? []) {
-                if (plan.qualification_status === "eligible" && plan.booking_input) {
-                    if (!plan.purchase_operation)
-                        throw new CommandContractError("public_operation_contract_invalid", "missing public purchase operation", "购买合同缺失", []);
-                    publicPurchaseTemplate(plan.purchase_operation);
-                }
-            }
-            if (detail.journey.booking_support === "single_leg" && detail.journey.booking_offer) {
-                if (!detail.journey.purchase_operation)
-                    throw new CommandContractError("public_operation_contract_invalid", "missing public purchase operation", "购买合同缺失", []);
-                publicPurchaseTemplate(detail.journey.purchase_operation);
-            }
-        };
-        try {
-            validate();
-        }
-        catch (error) {
-            if (!(error instanceof CommandContractError) || error.code !== "public_operation_contract_invalid")
-                throw error;
-            // One bounded owner-validated read, pinned to the returned snapshot. No provider or purchase call.
-            detail = await backend.getRailJourneyDetail(serviceExecutionID, options.journey, detail.snapshot_id);
-            try {
-                validate();
-            }
-            catch (repeated) {
-                if (!(repeated instanceof CommandContractError) || repeated.code !== "public_operation_contract_invalid")
-                    throw repeated;
-                throw new CommandContractError(repeated.code, repeated.message, "同一详情只读重取一次后购买合同仍不完整，停止。保留原执行和快照，需平台修复；不要重查、换候选、拼凭据或退旧入口。", [], undefined, { reason: "purchase_contract_missing", service_execution_id: serviceExecutionID, snapshot_id: detail.snapshot_id, journey_id: options.journey, readonly_recovery_attempts: 1 });
-            }
-        }
-        renderJourneyDetail(serviceExecutionID, detail, options);
-        return "handled";
-    }
-    return undefined;
-}

package/dist/src/services/rail/recovery.js

@@ -1,51 +0,0 @@
-import { HttpError } from "../../client/http.js";
-import { CommandContractError } from "../shared/envelope.js";
-export const RAIL_LOCATION_EVIDENCE_REASONS = new Set(["endpoint_kind_conflict", "place_identity_uncertain", "endpoint_adcode_name_conflict", "endpoint_poi_name_conflict", "endpoint_station_name_code_conflict", "location_evidence_required", "coordinate_name_mismatch", "area_scope_too_broad", "address_required", "administrative_area_unresolved", "station_location_evidence_required", "coordinate_identity_unverified"]);
-export const RAIL_QUOTE_FAILURE_GUIDANCE = {
-    quote_source_unavailable: "实时车票数据暂不可用；保留原选择，稍后按用户意愿重新核验，不创建替代订单。",
-    quote_train_changed: "所选车次的时刻或运行信息已变化；向用户说明并征询是否重新查票。",
-    quote_seat_changed: "所选席别已变化；向用户说明并征询新的席别选择。",
-    quote_seat_unavailable: "所选席别当前无足够余票；告知用户并由其决定是否换方案。",
-    quote_refresh_expired: "实时报价过程超时；保留原选择，不把旧价当可付款价格。",
-};
-export function railRunError(cause, serviceID, id) {
-    if (cause instanceof HttpError && ["invalid_selection", "selection_wrong_buyer"].includes(cause.code ?? "")) {
-        const reason = cause.payload?.reason;
-        const inputInvalid = reason === "input_constraint_invalid";
-        throw new CommandContractError(cause.code, cause.message, inputInvalid ? "输入违反当前完整计划约束。读取原查询的完整购买模板，修正人数、完整段数和顺序；不要追加未声明字段或拆单。"
-            : cause.code === "selection_wrong_buyer" ? "当前身份无权使用这份购买凭据。停止；不要切换身份绕过，也不展示其他买家资料。"
-                : reason === "stored_selection_inconsistent" ? "服务端凭据与已存目录不一致，补参数无法修复。停止购买并提供诊断标识 stored_selection_inconsistent；不猜字段、不重新创建购买。"
-                    : "购买凭据未通过校验，原因尚未确定且没有安全自动恢复。停止，不把推测报成原因或追加隐藏字段。", inputInvalid ? [{ command: "itpay services list --json", reason: "定位原查询并读取当前完整购买模板" }, { command: "itpay docs show rail-booking --json", reason: "读取正式输入约束" }] : [], undefined, { service_id: serviceID, ...(id ? { service_execution_id: id } : {}), ...(reason ? { reason } : {}), execution_created: Boolean(id) });
-    }
-    if (cause instanceof HttpError && cause.code === "rail_selection_expired") {
-        const expiry = cause.payload?.selection_expiry;
-        const bookingID = expiry?.booking_execution_id ?? id;
-        const refreshInput = !bookingID && expiry?.safe_new_query && ["itpay-rail-smart", "itpay-rail-exact"].includes(expiry.query_service_id) ? expiry.query_input : undefined;
-        const refresh = refreshInput !== undefined;
-        throw new CommandContractError(cause.code, cause.message, refresh ? "刚才余票信息已过时，按原条件刷新一次真实库存（可能消耗查询额度）；不需要重复批准同条件查票。有价格、库存或条款变化再确认；不复用旧库存、不换站或日期。"
-            : bookingID ? "保留原购买执行，先读取订单与付款事实；不要重新查票、创建替代购买或重复付款。"
-                : "旧选择凭据已过期，历史详情不能续期；缺少完整原查询条件或安全购买状态证据，停止自动刷新。", bookingID ? [{ command: `itpay services next ${bookingID} --json`, reason: "核对原购买执行和付款状态" }] : [], refreshInput && expiry ? { schema_version: "itpay.interaction.v1", stage: "input_required", input_template: {
-                command: `itpay services run ${expiry.query_service_id} --input-json <file> --json`, input: refreshInput, required_input: ["file"], executable: false,
-            } } : undefined, { service_id: serviceID, ...(bookingID ? { service_execution_id: bookingID } : {}), ...(expiry ? { selection_expiry: expiry } : {}) });
-    }
-    if (cause instanceof HttpError && cause.code === "rail_journey_selection_required") {
-        throw new CommandContractError(cause.code, cause.message, "整程必须使用原查询当前完整 ticket plan 的 selections 模板；手填 legs 只兼容单腿。缺少整程模板时读取原方案；不拆单、不拼腿、不擅自换站或日期。", [{ command: "itpay services list --json", reason: "找回原查询并读取其完整方案模板" }, { command: "itpay docs show rail-booking --json", reason: "读取正式整程输入合同" }], undefined, { service_id: serviceID, ...(id ? { service_execution_id: id } : {}) });
-    }
-    if (cause instanceof HttpError && cause.code === "rail_seat_code_invalid" && id) {
-        throw new CommandContractError(cause.code, cause.message, "席别必须使用原查询 booking_template.seat_choices 中与名称对应的代码，不能填“二等座”等显示名。用原 selection token 与真实人数修正输入，继续同一booking execution；若只是代码写法修正且车次、席别名称、人数等购买条件未变，沿用用户已给的确认，不再重复询问。", [{ command: `itpay services next ${id} --json`, reason: "读取同一booking当前状态后修正输入" }]);
-    }
-}
-export function railActionError(error, serviceExecutionID, actionType) {
-    if (error instanceof HttpError && ["booking_review_invalid", "booking_review_changed", "booking_review_locked"].includes(error.code)) {
-        throw new CommandContractError(error.code, error.message, error.code === "booking_review_invalid"
-            ? "确认输入与当前草稿不符。使用返回 interaction.input_template.input 当前review模板，席别使用返回的代码，不填显示名或猜新值。若仅修正代码写法，且车次、实际席别、人数、价格及条款等已确认内容未变，可沿用用户已有明确确认后提交；草稿实质变化或缺少真实同意时，先请用户确认变化内容。"
-            : error.code === "booking_review_changed"
-                ? "草稿版本已变化；使用同一booking的当前review模板。仅技术修正且车次、实际席别、人数、价格及条款未变时沿用已有明确同意；实质变化或缺少真实同意才补确认。"
-                : "当前购买已有付款尝试；读取同一booking及订单状态，不创建新订单或重做付款。", error.payload?.review ? [] : [{ command: `itpay services next ${serviceExecutionID} --json`, reason: "读取同一booking的当前状态与review" }], error.payload?.review?.input_template ? {
-            schema_version: "itpay.interaction.v1", stage: "consent_required",
-            consent_rule: "没有用户明确条款回答或等价已存同意时保持 false，展示 review.consent_question 后等待。技术修正不产生同意；Agent提交是转述。",
-            input_template: { command: `itpay services action ${serviceExecutionID} --action ${actionType} --actor-type agent --status approved --input-json <file> --json`, input: error.payload?.review.input_template, required_input: ["file"], executable: false },
-        } : undefined, { service_execution_id: serviceExecutionID, review: error.payload?.review, input_errors: error.payload?.input_errors });
-    }
-}
-export const railInputRecoveryInstruction = "Agent按当前模板自行修正错误字段和JSON层级，保留已有摘要的端点含义及原地点/日期/人数，不重复研究或事后补写冒充查询前摘要；不要向用户询问技术字段。只有真实业务歧义才问人；使用返回的执行身份恢复，未创建时用原服务。";