@danceiny/gotry 0.0.1-rc.21 → 0.0.1-rc.24

package/ts/src/artifact-gate.ts

@@ -18,10 +18,16 @@ import {
   hotelClaimVerdict,
   itineraryInvariants,
   latestFactsForRouteDate,
+  railClaimVerdict,
+  renderFlightFact,
+  renderHotelFact,
+  renderPolicyFact,
   type BookableFact,
   type FlightClaim,
   type FlightClaimVerdict,
   type ItineraryFacts,
+  type PolicyFact,
+  type RailClaim,
 } from './bookable-facts.ts'
 
 export const ARTIFACT_GATE_SCHEMA = 'gotry_artifact_gate.v1' as const
@@ -49,6 +55,19 @@ export interface ExtractedFlightClaim extends FlightClaim {
   carrier_only?: string
 }
 
+/** 车次 claim(issue #299):中文高铁/动车/城际/直达代码(G/D/C/Z + 3–4 位)。
+ * 闸侧不与航班 claim 合并;`railClaimVerdict` 只在 train 事实里查同号回溯,
+ * 缺事实/缺上下文 fail-closed(`rail_claim_unverified`),不得用历史班期或
+ * static-schedule 凑合格回溯。`gotry_flyai_search kind:'train'` 经
+ * `factsFromFlyai` 与 12306 `sessionTrainSearch` 均沿现有 typed fact log 接线;
+ * session 事实须通过 typed parser outcome + seat availability/freshness contract,
+ * 列表不含票价;
+ * 不新增 RailFact 渲染器,真实供应商可售性仍需独立证据。 */
+export interface ExtractedRailClaim extends RailClaim {
+  line: number
+  text: string
+}
+
 export interface ExtractedPolicyClaim {
   line: number
   text: string
@@ -74,6 +93,7 @@ export interface ExtractedHotelClaim {
 
 export interface ExtractedClaims {
   flights: ExtractedFlightClaim[]
+  trains: ExtractedRailClaim[]
   policies: ExtractedPolicyClaim[]
   airports: ExtractedAirportClaim[]
   /** 含「直飞」断言且可解析航线的行(通用直飞规则:该日无任何在架直飞即违例) */
@@ -83,8 +103,14 @@ export interface ExtractedClaims {
   anchors: Map<number, string>
 }
 
-/** 航班号:2 位承运码 + 3-4 位数字(UO784/EK328/MF1538/CZ8582/9C8781/FD597) */
+/** 航班号:2 位承运码 + 3-4 位数字(UO784/EK328/MF1538/CZ8582/9C8781/FD597)。
+ * 中文高铁/动车/城际/直达代码(G/D/C/Z + 3–4 位)由 `TRAIN_NO` 单独收集,
+ * 不进入航班 claim,issue #299。 */
 const FLIGHT_NO = /(?<![A-Za-z0-9])([A-Z0-9]{2}\d{3,4})(?![\d])/g
+/** 车次号:中文 G/D/C/Z + 3-4 位数字(G1234/D3112/C2001/Z1/Z9999)。issue #299:
+ * 闸侧 train claim 集合与航班 claim 完全分离,`flightClaimVerdict` 不再吞 train
+ * 事实,`railClaimVerdict` 只在 train 事实里查同号回溯。 */
+const TRAIN_NO = /(?<![A-Za-z0-9])([GDCZ]\d{3,4})(?![A-Za-z0-9])/g
 /** 承运级直飞断言:「8L 直飞」「FZ 直飞香港」——无航班号的航线存在性断言 */
 const CARRIER_DIRECT = /(?<![A-Za-z0-9])([A-Z0-9]{2})(?!\d)(?:\s|[一-龥]){0,6}直飞/g
 /** 中文承运名 → 二字码(承运级断言覆盖;只列闸需要的常见出境承运) */
@@ -92,11 +118,34 @@ const CARRIER_ZH: Record<string, string> = {
   东航: 'MU', 南航: 'CZ', 国航: 'CA', 厦航: 'MF', 春秋: '9C', 祥鹏: '8L',
   亚航: 'FD', 越捷: 'VZ', 国泰: 'CX', 港航: 'HX', 香港快运: 'UO', 阿联酋: 'EK', 泰航: 'TG',
 }
-const POLICY_WORD = /免签|落地签|签证|入境申报|过境免/
+/** Finite hotel-category vocabulary shared by heading activation and row recognition (issue #301). */
+const LODGING_VOCAB_RE = /酒店|住宿|客栈|民宿|度假村|青旅|青年旅舍|别墅|公寓/
+/** Markdown ATX heading level 1–6 (根实测 #347:5/6 级 lodging heading 必须激活) */
+const HEADING_ATX = /^(#{1,6})\s+(.+)$/
+/** 「政策」关键词(issue #273 父 + 子 #302):覆盖签证/免签/落地签/海关/过境五大类 + 子 #302 显式列举的政策词有限并集;
+ * 海关申报 与 入境申报 同性质但被原 regex 漏掉,补一个 demonstrative miss。
+ * 子 #302 扩词边界:仅 EVUS/ETA/eVisa/疫苗/疫苗接种/健康申报/隔离/工作签/居留/返程签/护照有效期/黄皮书/保险;拉丁 token
+ * 大小写不敏感但不嵌入更长 Latin 词(REVUS ≠ EVUS);不做 NLP/同义词/任意政策词表扩展。
+ * 子 #381(D-26 R1)扩词:入境章/落地章/出境章/入境卡/出境卡/出入境卡——与落地签同族的
+ * 移民章/卡六词,根反例「普吉岛入境章费用 800元」原全零抽取静默过闸,缺「截至」按既有
+ * policy_without_as_of 显式拒绝。仍为有限机械词表,可列举扩充、不做语义模型。 */
+const POLICY_WORD = /免签|落地签|入境章|落地章|出境章|入境卡|出境卡|出入境卡|签证|入境申报|海关申报|过境免|疫苗|疫苗接种|健康申报|隔离|工作签|居留|返程签|护照有效期|黄皮书|保险|(?<![A-Za-z])(?:EVUS|ETA|eVisa)(?![A-Za-z])/i
 /** as_of 必须是「截至 + 具体日期」——「现行 60 天」不算时间边界(issue #46 政策行) */
 const AS_OF_WORD = /截至\s*\d{4}[-/年]\d{1,2}|as[_ ]?of\s*\d{4}/i
 const CHECK_MARK = /[✓✅]/
 
+/** 交易承诺短语有限并集(D-26 R1,issue #381):费用/收费/押金/支付/缴费类下单措辞。
+ * 与「词表外金额写法」同一行同现、且该行经全部既有抽取原语后零 claim 时,按既有
+ * unverified_price_claim fail-closed。可列举扩充,不做 NLP/同义词/语义模型(#302 同款边界);
+ * 可订性短语(有房/可订)不在其中——由 §10/§12 酒店闸负责,其「裸短语不入闸」边界
+ * (#301/#347)保持不变。 */
+const COMMITMENT_TRANSACTION_RE = /费用|收费|手续费|服务费|签证费|通行费|通关费|小费|押金|定金|订金|机场税|港口税|支付|付款|缴款|缴费|现付|到付|付现|代订|代购/
+/** 受支持币种词表外的金额写法(D-26 R1,issue #381):`hardPricesInLine` 只识别
+ * ¥/[A-Z]{3} 前缀硬价;CJK 币种后缀({N}元/泰铢/美元…)与 $/＄ 前缀是其覆盖不了的
+ * 下单金额写法(根反例「800元」)。¥/ISO 前缀金额不在其中——零 claim 行的
+ * ¥/ISO 金额(预算/约价口径)属 R2 价格容忍度 founder 决策边界,不由本网拒绝。 */
+const OFF_VOCAB_AMOUNT_RE = /(?:\d[\d,]*(?:\.\d+)?\s*(?:元|美元|美金|泰铢|铢|日元|日圆|港币|港元|欧元|卢比|比索|林吉特|印尼盾|迪拉姆|里亚尔))|(?:[$＄]\s*\d[\d,]*(?:\.\d+)?)/
+
 /** 「直飞」断言(排除否定前置:无/不/没有/未见直飞;函数实现避开变宽 lookbehind 引擎差异) */
 function hasDirectAssertion(line: string): boolean {
   const idx = line.indexOf('直飞')
@@ -105,7 +154,7 @@ function hasDirectAssertion(line: string): boolean {
   return !(before.endsWith('无') || before.endsWith('不') || before.endsWith('没有') || before.endsWith('未见'))
 }
 
-interface SectionCtx { origin?: string; destination?: string; date?: string }
+interface SectionCtx { origin?: string; destination?: string; date?: string; /** 当前行是否在 lodging heading 上下文中(issue #301 无 token 行入闸) */ lodging?: boolean; /** 活动 lodging heading 的 ATX 层级栈(浅→深);同/更高级 non-lodging heading 弹出栈顶 */ lodgingDepths?: number[] }
 
 /** 行内第一个命中词表的城市中文名(酒店 claim 的目的地键;无命中=undefined) */
 function occ1(line: string, map: AirlineAirportMap): string | undefined {
@@ -161,7 +210,7 @@ function routeCtxOf(text: string, map: AirlineAirportMap, defaultYear?: number):
  * 行内自带上下文优先。默认年份由 trip window 提供(远期行程的年份不含糊)。
  */
 export function extractClaims(markdown: string, map: AirlineAirportMap, opts?: { trip_year?: number }): ExtractedClaims {
-  const claims: ExtractedClaims = { flights: [], policies: [], airports: [], direct_lines: [], hotels: [], anchors: new Map() }
+  const claims: ExtractedClaims = { flights: [], trains: [], policies: [], airports: [], direct_lines: [], hotels: [], anchors: new Map() }
   const lines = markdown.split('\n')
   let section: SectionCtx = {}
   // 渲染原语锚点(单向生成):带 fact:<id> 的行只走锚点确定性回溯,启发式抽取让位
@@ -174,9 +223,27 @@ export function extractClaims(markdown: string, map: AirlineAirportMap, opts?: {
       claims.anchors.set(lineNo, anchorMatch[1]!.toLowerCase())
       continue
     }
-    if (/^#{1,4}\s/.test(line)) {
+    if (HEADING_ATX.test(line)) {
       const ctx = routeCtxOf(line, map, opts?.trip_year)
-      section = { origin: ctx.origin, destination: ctx.destination, date: ctx.date ?? section.date }
+      // lodging heading 上下文栈(issue #301 真实反例:无 token 行入闸):
+      //  - lodging heading:在该层级压栈(更深栈顶替代外层语义,栈整体保留)
+      //  - 同级/更高级 non-lodging heading:弹栈直到空
+      //  - 更深的 non-lodging heading:继承栈
+      const headingMatch = line.match(HEADING_ATX)!
+      const headingLevel = headingMatch[1]!.length
+      const headingText = headingMatch[2]!
+      const isLodgingHeading = LODGING_VOCAB_RE.test(headingText)
+      const depths = (section.lodgingDepths ?? []).slice()
+      if (isLodgingHeading) {
+        // 同级 lodging heading 替换该层栈,更深的栈项保留
+        while (depths.length > 0 && depths[depths.length - 1]! >= headingLevel) depths.pop()
+        depths.push(headingLevel)
+      } else {
+        // 同级/更高级 non-lodging heading 弹出栈顶直至更浅或空
+        while (depths.length > 0 && depths[depths.length - 1]! >= headingLevel) depths.pop()
+      }
+      const lodging = depths.length > 0
+      section = { origin: ctx.origin, destination: ctx.destination, date: ctx.date ?? section.date, lodging, lodgingDepths: depths }
       continue
     }
     const own = routeCtxOf(line, map, opts?.trip_year)
@@ -184,8 +251,18 @@ export function extractClaims(markdown: string, map: AirlineAirportMap, opts?: {
     const destination = own.destination ?? section.destination
     const date = own.date ?? section.date
 
+    const trainNos = new Set([...line.matchAll(TRAIN_NO)].map(m => m[1]!.toUpperCase()))
+    for (const trainNo of trainNos) {
+      claims.trains.push({ line: lineNo, text: line.trim().slice(0, 120), flight_no: trainNo, origin, destination, date })
+    }
     for (const m of line.matchAll(FLIGHT_NO)) {
-      claims.flights.push({ line: lineNo, text: line.trim().slice(0, 120), flight_no: m[1]!.toUpperCase(), origin, destination, date })
+      const code = m[1]!.toUpperCase()
+      // 闸侧 train/flight 分离:中文高铁/动车/城际/直达前缀不得进入航班 claim。
+      // FLIGHT_NO 也会把 G1234 这类单字母车次整体匹配出来;只跳过同一行
+      // TRAIN_NO 实际命中的完整 token。不能按首字母跳过,否则合法双字母航司
+      // CZ8582 会被误删。
+      if (trainNos.has(code)) continue
+      claims.flights.push({ line: lineNo, text: line.trim().slice(0, 120), flight_no: code, origin, destination, date })
     }
     for (const m of line.matchAll(CARRIER_DIRECT)) {
       const carrier = m[1]!.toUpperCase()
@@ -207,10 +284,26 @@ export function extractClaims(markdown: string, map: AirlineAirportMap, opts?: {
     if (POLICY_WORD.test(line)) {
       claims.policies.push({ line: lineNo, text: line.trim().slice(0, 160), has_as_of: AS_OF_WORD.test(line) })
     }
-    // 酒店 claim(D-26):断言可住性(有房/可订/已核验/✓)的行——目的地与档期缺失时 fail-closed
-    const HOTEL_ASSERT = /酒店|住宿|客栈|民宿/
+    // 酒店 claim(D-26 + 子 #301 扩词):断言可住性(有房/可订/已核验/✓)的行——目的地与档期缺失时 fail-closed
+    // 父 #273 已有 酒店|住宿|客栈|民宿;子 #301 扩词覆盖 度假村/青旅/青年旅舍/别墅/公寓 五类非关键词住宿
+    // category(精品酒店 由 酒店 承接,不重复声明);lodging heading(§住宿/§酒店/§青旅 等,ATX 1–6)下完全无住宿类
+    // token 的可住断言也由 section.lodging 升为 hotel claim。行内匹配分两路:
+    //   (a) 行内含 LODGING_VOCAB_RE 词表 token → 需 HOTEL_BOOKABLE 短语/标记
+    //   (b) 行内无 token 但 lodging context 激活 → 需 HOTEL_BOOKABILITY 短语(有房/可订/.../可住),
+    //       单独的 ✓/✅ 不构成 bookability(例:`靠近地铁 ✓` 在 §住宿 下不是可订断言)。
+    //       检测到可订短语且带 ✓,未核验时再加 unconditional_check。
+    // 同级/更高级 non-lodging heading 退出上下文,更深 heading 继承;lodging depth 栈保留外层活动层级。
+    // 行内/heading 词汇同源 = LODGING_VOCAB_RE,不可漂移。无住宿类关键词仍走兜底 →
+    // unverifiable_hotel_claim(§10f 既有证据)。route/date section context 对航班逻辑不动;
+    // anchored 行由 `if (claims.anchors.has(c.line)) continue` 提前让位。
+    const HOTEL_BOOKABILITY = /有房|可订|在架|已核验|已验证|可住/
     const HOTEL_BOOKABLE = /有房|可订|在架|已核验|已验证|可住|✓|✅/
-    if (HOTEL_ASSERT.test(line) && HOTEL_BOOKABLE.test(line)) {
+    const hasCategoryToken = LODGING_VOCAB_RE.test(line)
+    const inLodgingSection = !!section.lodging
+    const isBookabilityClaim = hasCategoryToken
+      ? HOTEL_BOOKABLE.test(line)
+      : inLodgingSection && HOTEL_BOOKABILITY.test(line)
+    if (isBookabilityClaim) {
       const stays = [...line.matchAll(/(?<!\d)(\d{4}-\d{2}-\d{2})(?!\d)/g)].map(m => m[1]!)
       claims.hotels.push({
         line: lineNo,
@@ -249,7 +342,10 @@ export type GateViolationKind =
   | 'budget_floor_inconsistent'       // 预算下限话术低于分项最低合计
   | 'date_order'                      // 住宿/段日期越窗或倒挂
   | 'unverifiable_hotel_claim'        // 酒店可住断言无 exact-date 事实回溯(D-26)
+  | 'rail_claim_unverified'           // 车次 claim 无 train exact-date 事实回溯(issue #299)
   | 'fact_anchor_unknown'             // 渲染锚点 fact:<id> 在注册表不存在(锚点被手改/伪造)
+  | 'unverified_price_claim'          // 硬价缺少可比较的权威来源或可靠绑定(issue #300)
+  | 'price_contradicted'              // 行内可靠硬价格与 exact-date 事实价格冲突(issue #300)
 
 export interface GateViolation {
   kind: GateViolationKind
@@ -275,11 +371,228 @@ function lineTimesContradict(text: string, dep?: string, arr?: string): boolean
   return !times.some(t => t === dep || t === arr)
 }
 
+/** Renderer 固定的 reminder 短语正则(只此一句,日期为合法 ISO 阳历日)。
+ * 与 `policyCanonicalBody` 同源;闸侧只识别这一固定短语+位置(尾随在
+ * `[<source>@<fetched_at> #<query_id>]` 锚点块之前、收尾 `<!-- fact:<id> -->` 之前)。
+ * 用于 no-context 兼容性回退:从此正则抽日期,重建 `{...f, review_by: date}` 经
+ * renderer 还原整行,byte-for-byte 比对——不再手动拆 body/provenance。 */
+const POLICY_REMINDER_PHRASE_RE = /;远期政策须复核——到 (\d{4}-\d{2}-\d{2}) 再核验一次/
+
+interface HardPrice {
+  amount: number
+  currency: string
+  token: string
+  start: number
+}
+
+/**
+ * 只抽取行内可可靠绑定的硬价。起价/约价/模糊值不进入比较，不支持的币种
+ * 只进入未核验分支；不做汇率换算，也不把酒店 priceRaw 带入这里(issue #300)。
+ */
+function hardPricesInLine(text: string): HardPrice[] {
+  const prices: HardPrice[] = []
+  const amount = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`
+  const pattern = new RegExp(String.raw`(?:¥\s*(${amount})(?![\dA-Za-z,])|\b([A-Z]{3})\s*(${amount})(?![\dA-Za-z,]))`, 'gi')
+  for (const match of text.matchAll(pattern)) {
+    const amountText = match[1] ?? match[3]
+    if (!amountText || match.index === undefined) continue
+    const before = text.slice(Math.max(0, match.index - 8), match.index)
+    const after = text.slice(match.index + match[0].length, match.index + match[0].length + 8)
+    if (/(?:约|大约|约为|起价|起步|from)\s*$/i.test(before)
+      || /^\s*(?:起|起价|起步|左右|上下|以上|\+)/i.test(after)) continue
+    prices.push({
+      amount: Number(amountText.replaceAll(',', '')),
+      currency: match[1] ? 'CNY' : match[2]!.toUpperCase(),
+      token: amountText,
+      start: match.index,
+    })
+  }
+  return prices
+}
+
+interface MalformedHardPrice {
+  currency: string
+  token: string
+  start: number
+}
+
+/**
+ * 先识别完整 token 之外的畸形逗号数字;¥7xx 等既有非数字/模糊值不在此列。
+ */
+function malformedHardPricesInLine(text: string): MalformedHardPrice[] {
+  const amount = String.raw`(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?`
+  const token = String.raw`\d[\d,]*(?:\.\d+)?`
+  const pattern = new RegExp(String.raw`(?:¥\s*|\b([A-Z]{3})\s*)(${token})(?![\dA-Za-z])`, 'gi')
+  const malformed: MalformedHardPrice[] = []
+  for (const match of text.matchAll(pattern)) {
+    const raw = match[2]
+    if (!raw || !raw.includes(',') || new RegExp(`^(?:${amount})$`).test(raw)) continue
+    malformed.push({ currency: match[1] ? match[1].toUpperCase() : 'CNY', token: raw, start: match.index ?? 0 })
+  }
+  return malformed
+}
+
+interface MoneyField {
+  text: string
+  offset: number
+  index: number
+}
+
+interface AmbiguousHardPrice {
+  currency: string
+  token: string
+  start: number
+}
+
+interface FareRoleAnalysis {
+  prices: HardPrice[]
+  malformed: MalformedHardPrice[]
+  ambiguous: AmbiguousHardPrice[]
+}
+
+function moneyFields(text: string): MoneyField[] {
+  const fields = text.split(/[；;|，]/)
+  const scopes: MoneyField[] = []
+  let offset = 0
+  for (const [index, field] of fields.entries()) {
+    scopes.push({ text: field, offset, index })
+    offset += field.length + 1
+  }
+  return scopes
+}
+
+const EXPLICIT_FARE_LABEL = /(?:票价|机票价|fare|price)\s*[:：]?\s*$/i
+const PREVIOUS_MONEY_TOKEN = /(?:¥\s*|\b[A-Z]{3}\s*)\d[\d,]*(?:\.\d+)?\s*$/i
+
+/**
+ * 分类 money role,而不是把「同一行」当成 fare:
+ * canonical 是第一个 money token 所在的首字段;后续 token 只有显式
+ * fare label 才可比。其它有文字标签的字段忽略;裸 token 或前面只是
+ * 另一个金额的 token 无可靠归属,必须 fail closed。
+ */
+function analyzeFareRoles(text: string): FareRoleAnalysis {
+  const analysis: FareRoleAnalysis = { prices: [], malformed: [], ambiguous: [] }
+  for (const field of moneyFields(text)) {
+    const prices = hardPricesInLine(field.text)
+    const malformed = malformedHardPricesInLine(field.text)
+    const tokens = [
+      ...prices.map(price => ({ kind: 'complete' as const, start: price.start, price, malformed: undefined })),
+      ...malformed.map(item => ({ kind: 'malformed' as const, start: item.start, price: undefined, malformed: item })),
+    ].sort((a, b) => a.start - b.start)
+    for (const [tokenIndex, token] of tokens.entries()) {
+      const prefix = field.text.slice(0, token.start).trim()
+      const canonical = field.index === 0 && tokenIndex === 0
+      const explicitFare = EXPLICIT_FARE_LABEL.test(prefix)
+      const reliableFare = canonical || explicitFare
+      if (reliableFare) {
+        if (token.price) analysis.prices.push({ ...token.price, start: token.price.start + field.offset })
+        if (token.malformed) analysis.malformed.push({ ...token.malformed, start: token.malformed.start + field.offset })
+        continue
+      }
+      // A bare token, or a token immediately following another money token,
+      // is ambiguous; any other textual prefix accounts for a non-fare field.
+      if (prefix.length === 0 || PREVIOUS_MONEY_TOKEN.test(prefix)) {
+        const currency = token.price?.currency ?? token.malformed?.currency ?? 'CNY'
+        const raw = token.price?.token ?? token.malformed?.token ?? ''
+        analysis.ambiguous.push({ currency, token: raw, start: token.start + field.offset })
+      }
+    }
+  }
+  return analysis
+}
+
+function flightTrainPriceScope(text: string, fact: Extract<BookableFact, { kind: 'flight' | 'train' }>): string {
+  const no = fact.flight_no.toUpperCase()
+  const noStart = text.toUpperCase().indexOf(no)
+  if (noStart < 0) return ''
+  const afterNo = text.slice(noStart + no.length)
+  const nextFlight = afterNo.match(FLIGHT_NO)
+  const anchor = text.indexOf('<!-- fact:', noStart + no.length)
+  const evidence = afterNo.search(/\[[^\]\n]*#[^\]\n]*\]/)
+  let end = text.length
+  if (nextFlight?.index !== undefined) end = Math.min(end, noStart + no.length + nextFlight.index)
+  // The rendered fare is before its evidence chain; amounts after it are
+  // unrelated fees/budget text even when an anchor follows later on the line.
+  if (evidence >= 0) end = Math.min(end, noStart + no.length + evidence)
+  if (anchor >= 0) end = Math.min(end, anchor)
+  return text.slice(noStart, end)
+}
+
+function addPriceVerification(
+  violations: GateViolation[],
+  line: number,
+  fullText: string,
+  visibleText: string,
+  fact: Extract<BookableFact, { kind: 'flight' | 'train' }>,
+): boolean {
+  const fullScope = flightTrainPriceScope(fullText, fact)
+  const visibleScope = flightTrainPriceScope(visibleText, fact)
+  const fullAnalysis = analyzeFareRoles(fullScope)
+  const visibleAnalysis = analyzeFareRoles(visibleScope)
+  const allPrices = fullAnalysis.prices
+  const visiblePrices = visibleAnalysis.prices
+  const hasAnchor = fullText.includes('<!-- fact:')
+
+  if (fullAnalysis.malformed.length > 0 || fullAnalysis.ambiguous.length > 0) {
+    const malformed = fullAnalysis.malformed[0]
+    const ambiguous = fullAnalysis.ambiguous[0]
+    violations.push({
+      kind: 'unverified_price_claim',
+      line,
+      detail: malformed
+        ? `${fact.flight_no} fare role 含畸形硬价格 ${malformed.currency} ${malformed.token}——数字分组不完整,按未核验处理,不得截断或当作完整票价比较`
+        : `${fact.flight_no} 行内硬价格 ${ambiguous?.currency ?? 'CNY'} ${ambiguous?.token ?? ''} 无可靠 fare role 归属——按未核验处理,不得把裸金额当作 exact-date 票价`,
+    })
+    return true
+  }
+
+  // Heuristic claims retain the existing 120-character extraction window. If a
+  // hard price only appears outside it, it cannot be safely bound to this claim.
+  if (!hasAnchor && allPrices.some(p => p.start >= visibleScope.length)) {
+    violations.push({
+      kind: 'unverified_price_claim',
+      line,
+      detail: `${fact.flight_no} 行内硬价格未锚定且超出 120 字抽取窗口——无法作为 exact-date 事实核验,按未核验处理`,
+    })
+    return true
+  }
+
+  if (allPrices.length === 0) return false
+  const factCurrency = fact.currency?.toUpperCase()
+  for (const rendered of visiblePrices) {
+    if (fact.price === undefined || !Number.isFinite(fact.price) || factCurrency !== 'CNY') {
+      violations.push({
+        kind: 'unverified_price_claim',
+        line,
+        detail: `${fact.flight_no} 行内硬价格 ${rendered.currency} ${rendered.amount} 缺少可比较的权威 exact-date 事实价格——按未核验处理,不作汇率或币种猜测`,
+      })
+      return true
+    }
+    // ¥/CNY only compare against a CNY fact. No FX or ambiguous-currency guess.
+    if (rendered.currency !== factCurrency) {
+      violations.push({
+        kind: 'unverified_price_claim',
+        line,
+        detail: `${fact.flight_no} 行内硬价格 ${rendered.currency} ${rendered.amount} 不支持直接比较事实 ${factCurrency} ${fact.price}——按未核验处理,不作汇率换算`,
+      })
+      return true
+    }
+    if (rendered.amount === fact.price) continue
+    violations.push({
+      kind: 'price_contradicted',
+      line,
+      detail: `${fact.flight_no} 行内硬价格 ${rendered.currency} ${rendered.amount} ≠ exact-date 事实 ${factCurrency} ${fact.price}——价格事实矛盾,不得改写工具返回价格`,
+    })
+    return true
+  }
+  return false
+}
+
 export function gateArtifact(
   markdown: string,
   facts: BookableFact[],
   map: AirlineAirportMap,
-  opts?: { trip_year?: number; itinerary?: ItineraryFacts },
+  opts?: { trip_year?: number; itinerary?: ItineraryFacts; tripStart?: string },
 ): GateReport {
   const claims = extractClaims(markdown, map, opts)
   const violations: GateViolation[] = []
@@ -287,16 +600,196 @@ export function gateArtifact(
 
   // 渲染锚点优先(issue #118 单向生成):带 fact:<id> 的行确定性回溯注册表——
   // 锚点在=按事实 bookability 判;锚点不存在=手改/伪造,直接违例。启发式对锚点行让位。
+  const lines = markdown.split('\n')
   for (const [lineNo, factId] of claims.anchors) {
     const f = facts.find(x => x.fact_id === factId)
     if (!f) {
       violations.push({ kind: 'fact_anchor_unknown', line: lineNo, detail: `渲染锚点 fact:${factId} 不在事实注册表——锚点被手改或伪造,产物不可信` })
       continue
     }
+    if (f.kind === 'train') {
+      const rendered = lines[lineNo - 1] ?? ''
+      const canonical = renderFlightFact(f)
+      if (rendered.trim() !== canonical.trim()) {
+        violations.push({
+          kind: 'fact_anchor_unknown',
+          line: lineNo,
+          detail: `train 锚点行与 canonical renderer 不一致——车次/时刻/日期/route 可能被手改;期望 ${canonical}`,
+        })
+        continue
+      }
+      const rail = railClaimVerdict(facts, {
+        flight_no: f.flight_no,
+        origin: f.route.origin,
+        destination: f.route.destination,
+        date: f.date,
+      })
+      if (rail.verdict !== 'traceable') {
+        violations.push({ kind: 'rail_claim_unverified', line: lineNo, detail: `${f.flight_no}: 锚点未通过 train exact-date 回溯(${rail.verdict})——${rail.reason}` })
+        continue
+      }
+    }
+    // 航班锚点行字段指纹(issue #363,D-26 残余收口):锚点存在 ≠ 可见
+    // 内容与事实一致——flight_no 是「锚点 + 渲染原语」之间唯一可手改的
+    // 关键字段,保留 fact_id/anchor/registry 而改 flight_no(UO724→UO999)
+    // 仍会被「同号回溯」路径误判为 traceable,根反例验收正是此形态。
+    // 闸侧改用字段指纹:从渲染行重新抽 flight_no token,必须严格 ==
+    // 事实 flight_no。同一字段不引入 whole-line equality;承运/时刻/route/
+    // 日期/价格/打码段的兼容(§4b + §9 + §10 + §11)继续由既有判定
+    // 原语负责,不被新指纹吞并。同一行 trip-test 不命中即 fail-closed。
+    if (f.kind === 'flight') {
+      const rendered = lines[lineNo - 1] ?? ''
+      const canonicalFlightNo = f.flight_no.toUpperCase()
+      const renderedFlightNo = (() => {
+        for (const m of rendered.matchAll(FLIGHT_NO)) {
+          const code = m[1]?.toUpperCase()
+          if (code) return code
+        }
+        return undefined
+      })()
+      if (!renderedFlightNo || renderedFlightNo !== canonicalFlightNo) {
+        violations.push({
+          kind: 'fact_anchor_unknown',
+          line: lineNo,
+          detail: `flight 锚点行 flight_no 字段指纹不符——锚点存在但 visible flight_no 与事实 ${canonicalFlightNo} 不一致(渲染抽到 ${renderedFlightNo ?? '∅'});保留 fact_id/registry/anchor 改写可见航班号不被允许,期望行内含 ${canonicalFlightNo}`,
+        })
+        continue
+      }
+    }
+    // 酒店锚点行字段指纹(issue #363,D-26 残余收口):destination + 档期
+    // 是「锚点 + 渲染原语」之间可手改的关键字段;保留 fact_id/anchor/
+    // registry 改写 目的地(大理→丽江)或 档期(2026-10-01→2026-12-25)
+    // 仍会被 hotelClaimVerdict 的同目的地同档期回溯判为 traceable,
+    // 根反例验收正是此形态。闸侧改为字段指纹:渲染行必须严格包含
+    // 事实的 destination(精确子串)+ check_in(精确子串)+ check_out
+    // (精确子串)三项;任一缺失或不一致 → fact_anchor_unknown fail-closed。
+    // 不引入 whole-line equality;价格打码/承运/时刻/政策的兼容形态
+    // 继续由既有判定原语负责。打码语义(options_masked = 9)与酒店事实
+    // 无 price 字段不变。
+    if (f.kind === 'hotel') {
+      const rendered = lines[lineNo - 1] ?? ''
+      const expectedDestination = f.destination
+      const expectedCheckIn = f.check_in
+      const expectedCheckOut = f.check_out
+      const missingDestination = !!expectedDestination && !rendered.includes(expectedDestination)
+      const missingCheckIn = !!expectedCheckIn && !rendered.includes(expectedCheckIn)
+      const missingCheckOut = !!expectedCheckOut && !rendered.includes(expectedCheckOut)
+      if (missingDestination || missingCheckIn || missingCheckOut) {
+        violations.push({
+          kind: 'fact_anchor_unknown',
+          line: lineNo,
+          detail: `hotel 锚点行字段指纹不符——锚点存在但 visible destination=${expectedDestination ?? '∅'}/check_in=${expectedCheckIn ?? '∅'}/check_out=${expectedCheckOut ?? '∅'} 与事实字段不严格一致(渲染行=${JSON.stringify(rendered)});保留 fact_id/registry/anchor 改写可见目的地或档期不被允许`,
+        })
+        continue
+      }
+    }
     if (f.kind !== 'policy' && f.bookability === 'unavailable_exact_date') {
       violations.push({ kind: 'not_in_source', line: lineNo, detail: `锚点事实为 exact-date 负事实(${(f as { fetched_at?: string }).fetched_at ?? ''})——负事实对应的可住/可订断言不得出现` })
       continue
     }
+    // 政策行内容指纹(issue #273 + #359,D-26 残余收口):
+    // 整行 = canonical body + ` <!-- fact:<id> -->`,单一权威面与 renderPolicyFact
+    // 共享 `policyCanonicalBody` 构造器;subject/statement/source/fetched_at/
+    // query_id/as_of 任一改动 → 行文本不再等于 canonical → fact_anchor_unknown
+    // fail-closed。锚点行不得含前导非空文本(允许锚点前的尾随空白)、第二个
+    // `<!-- fact:` 锚点、或任何「借合法锚点却写相反政策」的借用形态;行尾只允许
+    // `<!-- fact:<id> -->` 收尾。
+    //
+    // 兼容性回退(legacy public callers):当调用面未传 `opts.tripStart` 且未在
+    // itinerary 给出 `trip_start` 时,闸侧额外接受 renderer 产出的两个 canonical
+    // 形态之一(no-reminder 与 renderer-fixed 提醒 `;远期政策须复核——
+    // 到 YYYY-MM-DD 再核验一次`,日期为合法 ISO 阳历日)。这是 renderer 固定
+    // 短语+位置,不是任意 body 改写或后缀。该回退只匹配 renderer 自身输出,
+    // 不重新拼装、不猜 tripStart、不动 fact_id;有 `opts.tripStart` 或
+    // `itinerary.trip_start` 时优先严格比对对应 reminder,不退到回退集合。
+    if (f.kind === 'policy') {
+      const rendered = lines[lineNo - 1] ?? ''
+      // Precedence(issue #359 direct-API contract):explicit `opts.tripStart` →
+      // `opts.itinerary.trip_start` → undefined。policy 分支渲染上下文相关
+      // canonical 行(严格比对 + 结构失败诊断)全部走同一个
+      // `effectiveTripStart`,不再要求调用方在 `opts.tripStart` 与
+      // `itinerary.trip_start` 之间复制同一天。原来由 `index.ts` 桥接
+      // itinerary → tripStart 的注册路径仍然兼容(显式 tripStart 优先,语义不变)。
+      const explicitTripStart = typeof opts?.tripStart === 'string' && opts.tripStart.length > 0 ? opts.tripStart : undefined
+      const itineraryTripStart = typeof opts?.itinerary?.trip_start === 'string' && opts.itinerary.trip_start.length > 0
+        ? opts.itinerary!.trip_start
+        : undefined
+      const effectiveTripStart: string | undefined = explicitTripStart ?? itineraryTripStart
+      const anchorRe = /<!-- fact:([0-9a-f]{16}) -->/
+      const m = rendered.match(anchorRe)
+      const noSecondAnchor = !m || m.index === undefined
+        ? true
+        : !rendered.slice(0, m.index).includes('<!-- fact:')
+      const exactlyOneAnchor = m && m.index !== undefined && noSecondAnchor
+      const trailingNonEmpty = m && m.index !== undefined
+        ? /\S/.test(rendered.slice(m.index + m[0]!.length))
+        : true
+      const exactAnchorId = m && m.index !== undefined && m[1] === f.fact_id
+      const structureOk = exactlyOneAnchor && exactAnchorId && !trailingNonEmpty
+      if (!structureOk) {
+        const canonical = renderPolicyFact(f, effectiveTripStart)
+        violations.push({
+          kind: 'fact_anchor_unknown',
+          line: lineNo,
+          detail: `政策锚点行结构不合法——必须为 canonical body + 单一「 <!-- fact:<id> -->」且行尾无后置非空文本(检测:行=${JSON.stringify(rendered)},期望=${JSON.stringify(canonical)});手改/伪造锚点或借用合法锚点写相反政策均 fail-closed`,
+        })
+        continue
+      }
+      const hasExplicitTripContext = effectiveTripStart !== undefined
+      if (!hasExplicitTripContext) {
+        // 兼容性回退(legacy public callers):仅当事实无 `review_by` 时,接受
+        // renderer 产出的两个固定 canonical 形态——不手动拆 body/provenance。
+        //   (a) no-reminder 行 —— 严格等于 `renderPolicyFact(f)`。
+        //   (b) reminder 行 —— 从 renderer 固定短语里**只抽日期**,把日期塞回
+        //       `{...f, review_by: date}` 经 renderer 重建整行,与原行 byte-for-byte
+        //       比对;同时校验日期是真实 ISO 阳历日。这样 subject/statement/source/
+        //       fetched_at/query_id/as_of、reminder 位置/短语、锚点结构、provenance
+        //       块全都由 renderer 重新产出并比对,不再人工拆段。
+        //   若事实自带 `review_by`,renderer 唯一合法 reminder 日期就是 `f.review_by`;
+        //   (a) 已涵盖合法 pass;(b) 走 `{...f, review_by: extractedDate}` 时若
+        //   extractedDate ≠ `f.review_by` 必因重建 ≠ 原行而 fall through,fail-closed。
+        if (rendered === renderPolicyFact(f)) {
+          traceable++
+          continue
+        }
+        if (typeof f.review_by !== 'string') {
+          const remMatch = rendered.match(POLICY_REMINDER_PHRASE_RE)
+          if (remMatch) {
+            const isoDate = remMatch[1]!
+            const realIso = (() => {
+              const dm = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDate)
+              if (!dm) return false
+              const y = Number(dm[1]); const mo = Number(dm[2]); const da = Number(dm[3])
+              if (mo < 1 || mo > 12 || da < 1 || da > 31) return false
+              const test = new Date(Date.UTC(y, mo - 1, da))
+              return test.getUTCFullYear() === y && test.getUTCMonth() === mo - 1 && test.getUTCDate() === da
+            })()
+            if (realIso && rendered === renderPolicyFact({ ...f, review_by: isoDate })) {
+              traceable++
+              continue
+            }
+          }
+        }
+      }
+      // 即使 trip 上下文已知,renderer 不接 tripStart 时也会产出 no-reminder canonical;
+      // 该形态与 `renderPolicyFact(f)` 严格相等,在此处也必须合法(renderer 的
+      // tripStart argument 是 optional)。否则闸会把「renderer 选择不带 reminder」
+      // 误判成内容指纹不符,误伤合法事实行。
+      if (rendered === renderPolicyFact(f)) {
+        traceable++
+        continue
+      }
+      const canonical = renderPolicyFact(f, effectiveTripStart)
+      if (rendered !== canonical) {
+        violations.push({
+          kind: 'fact_anchor_unknown',
+          line: lineNo,
+          detail: `政策锚点行内容指纹不符——期望 ${canonical},实际 ${rendered};subject/statement/source/fetched_at/query_id/as_of 任一不一致均 fail-closed`,
+        })
+        continue
+      }
+    }
+    if ((f.kind === 'flight' || f.kind === 'train') && addPriceVerification(violations, lineNo, lines[lineNo - 1] ?? '', lines[lineNo - 1] ?? '', f)) continue
     traceable++
   }
 
@@ -305,6 +798,10 @@ export function gateArtifact(
     if (claims.anchors.has(c.line)) continue
     if (!c.destination) {
       violations.push({ kind: 'unverifiable_hotel_claim', line: c.line, detail: `酒店可住断言缺目的地上下文,无法回溯 exact-date 事实——fail closed 按未核验处理` })
+      // 无目的地时也检查无条件 ✓:对未核验住宿仍不应打确定性标记
+      if (CHECK_MARK.test(c.text)) {
+        violations.push({ kind: 'unconditional_check', line: c.line, detail: '对未核验酒店使用无条件 ✓/✅——只有 bookable_exact_date 才允许确定性标记' })
+      }
       continue
     }
     const r = hotelClaimVerdict(facts, { destination: c.destination, check_in: c.check_in, check_out: c.check_out })
@@ -333,7 +830,7 @@ export function gateArtifact(
         && (!c.date || f.date === c.date))
       if (!hasCarrier) {
         const scoped = c.origin && c.destination && c.date
-          ? latestFactsForRouteDate(facts, c.origin, c.destination, c.date)
+          ? latestFactsForRouteDate(facts, c.origin, c.destination, c.date, 'flight')
           : []
         violations.push({
           kind: scoped.length > 0 ? 'not_in_source' : 'carrier_direct_unverified',
@@ -356,6 +853,7 @@ export function gateArtifact(
         })
         continue
       }
+      if (r.fact && addPriceVerification(violations, c.line, lines[c.line - 1] ?? '', c.text, r.fact)) continue
       traceable++
       continue
     }
@@ -366,6 +864,31 @@ export function gateArtifact(
     }
   }
 
+  // 车次 claim 独立于航班 claim:同 route/date 的航班事实不能证明车次存在,
+  // 也不能把缺失车次写成通用 not_in_source。只有 train kind 的结构化
+  // exact-date 事实才可回溯;不存在 renderRailFact 或 static schedule 降级。
+  for (const c of claims.trains) {
+    if (claims.anchors.has(c.line)) continue
+    const r = railClaimVerdict(facts, c)
+    if (r.verdict === 'traceable') {
+      if (lineTimesContradict(c.text, r.fact?.dep_local, r.fact?.arr_local)) {
+        violations.push({
+          kind: 'rail_claim_unverified',
+          line: c.line,
+          detail: `${c.flight_no} 时刻与 train exact-date 快照不符(快照 ${r.fact?.dep_local}→${r.fact?.arr_local} ${r.fact?.date})——不得改写结构化车次事实`,
+        })
+        continue
+      }
+      if (r.fact && addPriceVerification(violations, c.line, lines[c.line - 1] ?? '', c.text, r.fact)) continue
+      traceable++
+      continue
+    }
+    violations.push({ kind: 'rail_claim_unverified', line: c.line, detail: `${c.flight_no}: ${r.verdict}——${r.reason}` })
+    if (CHECK_MARK.test(c.text)) {
+      violations.push({ kind: 'unconditional_check', line: c.line, detail: `对未核验车次 ${c.flight_no} 使用无条件 ✓/✅——只有 train bookable_exact_date 才允许确定性标记` })
+    }
+  }
+
   // 通用直飞规则:该行未点名承运时,要求该 route+date 存在任一在架直飞;
   // 「该日可售仅有中转/0 条」却写直飞 = 无证据分支(issue #46「DMK→KMG 可考虑 8L 直飞」行同款)
   for (const d of claims.direct_lines) {
@@ -374,7 +897,7 @@ export function gateArtifact(
       violations.push({ kind: 'route_unqueried', line: d.line, detail: `直飞断言缺 route/date 上下文,无法回溯——fail closed 按未核验处理` })
       continue
     }
-    const scoped = latestFactsForRouteDate(facts, d.origin, d.destination, d.date)
+    const scoped = latestFactsForRouteDate(facts, d.origin, d.destination, d.date, 'flight')
     if (scoped.length === 0) {
       violations.push({ kind: 'route_unqueried', line: d.line, detail: `${d.origin}→${d.destination} ${d.date} 的直飞断言从未经 exact-date 源核验` })
       continue
@@ -408,11 +931,34 @@ export function gateArtifact(
     }
   }
 
+  // 词表外下单措辞 fail-closed(D-26 R1,issue #381,接管 #273 公开跟踪):
+  // 根反例(main 6e85d36)「普吉岛入境章费用 800元，现场支付」全零抽取静默过闸。
+  // 兜底词网:仅当(1)该行经全部既有抽取原语(锚点/航班/车次/政策/酒店/机场映射/
+  // 直飞)后零 claim,且(2)行内同时命中交易承诺短语与词表外金额写法,才按既有
+  // unverified_price_claim 显式拒绝——不发明新违例通道。已有 claim 的行由各自
+  // 既有机制负责,词网不重复计违例;heading 行与抽取面一致不入网。
+  const claimedLines = new Set<number>(claims.anchors.keys())
+  for (const c of [...claims.flights, ...claims.trains, ...claims.policies, ...claims.hotels, ...claims.airports, ...claims.direct_lines]) claimedLines.add(c.line)
+  lines.forEach((line, idx) => {
+    const lineNo = idx + 1
+    if (claimedLines.has(lineNo) || HEADING_ATX.test(line)) return
+    if (COMMITMENT_TRANSACTION_RE.test(line) && OFF_VOCAB_AMOUNT_RE.test(line)) {
+      violations.push({
+        kind: 'unverified_price_claim',
+        line: lineNo,
+        detail: '词表外下单措辞 fail-closed:该行含交易承诺措辞且金额为受支持币种词表(¥/ISO 前缀)外的写法,无 exact-date 事实可回溯——按未核验价格处理,不得静默过闸;改用渲染原语锚点或附「截至 YYYY-MM-DD」可溯来源(D-26 R1,issue #381)',
+      })
+    }
+  })
+
   // 联程措辞:含「联程」的行,逐航班号查 protected_connection——
   // 只有全部航腿同票保护才允许称联程;分票/自助转机必须显式标红
   markdown.split('\n').forEach((line, i) => {
     if (!line.includes('联程')) return
-    const nos = [...line.matchAll(FLIGHT_NO)].map(m => m[1]!.toUpperCase())
+    const trainNos = new Set([...line.matchAll(TRAIN_NO)].map(m => m[1]!.toUpperCase()))
+    const nos = [...line.matchAll(FLIGHT_NO)]
+      .map(m => m[1]!.toUpperCase())
+      .filter(no => !trainNos.has(no))
     const matched = facts.filter((f): f is Extract<BookableFact, { kind: 'flight' | 'train' }> =>
       (f.kind === 'flight' || f.kind === 'train') && nos.includes(f.flight_no.toUpperCase()))
     const allProtected = nos.length > 0
@@ -437,7 +983,7 @@ export function gateArtifact(
   return {
     schema: ARTIFACT_GATE_SCHEMA,
     verdict: violations.length > 0 ? 'blocked' : 'pass',
-    claims_checked: claims.flights.length + claims.policies.length + claims.airports.length,
+    claims_checked: claims.flights.length + claims.trains.length + claims.policies.length + claims.airports.length,
     traceable,
     violations,
     presentation: violations.length > 0 ? 'verified_label_forbidden' : 'verified_itinerary_allowed',