@danceiny/gotry 0.0.1-rc.17 → 0.0.1-rc.19

package/ts/src/artifact-gate.ts

@@ -15,6 +15,7 @@
 
 import {
   flightClaimVerdict,
+  hotelClaimVerdict,
   itineraryInvariants,
   latestFactsForRouteDate,
   type BookableFact,
@@ -62,12 +63,24 @@ export interface ExtractedAirportClaim {
   city: string
 }
 
+/** 酒店 claim(D-26):断言「有房/可订/已核验」的行——目的地与档期缺失时 fail-closed */
+export interface ExtractedHotelClaim {
+  line: number
+  text: string
+  destination?: string
+  check_in?: string
+  check_out?: string
+}
+
 export interface ExtractedClaims {
   flights: ExtractedFlightClaim[]
   policies: ExtractedPolicyClaim[]
   airports: ExtractedAirportClaim[]
   /** 含「直飞」断言且可解析航线的行(通用直飞规则:该日无任何在架直飞即违例) */
   direct_lines: Array<{ line: number; text: string; origin?: string; destination?: string; date?: string }>
+  hotels: ExtractedHotelClaim[]
+  /** 渲染原语锚点(fact:<id>):命中行只走确定性回溯,启发式让位 */
+  anchors: Map<number, string>
 }
 
 /** 航班号:2 位承运码 + 3-4 位数字(UO784/EK328/MF1538/CZ8582/9C8781/FD597) */
@@ -94,6 +107,14 @@ function hasDirectAssertion(line: string): boolean {
 
 interface SectionCtx { origin?: string; destination?: string; date?: string }
 
+/** 行内第一个命中词表的城市中文名(酒店 claim 的目的地键;无命中=undefined) */
+function occ1(line: string, map: AirlineAirportMap): string | undefined {
+  for (const city of Object.keys(map.city_alias)) {
+    if (line.includes(city)) return city
+  }
+  return undefined
+}
+
 /** 从文本(小节标题或行)解析航线上下文:箭头紧邻城市对(方向最可靠)优先,否则按出现位置取前两个;日期 M.D 或 MM-DD */
 function routeCtxOf(text: string, map: AirlineAirportMap, defaultYear?: number): SectionCtx {
   const occ: Array<{ city: string; iata: string; pos: number }> = []
@@ -140,12 +161,19 @@ 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: [] }
+  const claims: ExtractedClaims = { flights: [], policies: [], airports: [], direct_lines: [], hotels: [], anchors: new Map() }
   const lines = markdown.split('\n')
   let section: SectionCtx = {}
+  // 渲染原语锚点(单向生成):带 fact:<id> 的行只走锚点确定性回溯,启发式抽取让位
+  const ANCHOR = /fact:([0-9a-f]{16})/
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]!
     const lineNo = i + 1
+    const anchorMatch = line.match(ANCHOR)
+    if (anchorMatch) {
+      claims.anchors.set(lineNo, anchorMatch[1]!.toLowerCase())
+      continue
+    }
     if (/^#{1,4}\s/.test(line)) {
       const ctx = routeCtxOf(line, map, opts?.trip_year)
       section = { origin: ctx.origin, destination: ctx.destination, date: ctx.date ?? section.date }
@@ -179,6 +207,19 @@ 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 = /酒店|住宿|客栈|民宿/
+    const HOTEL_BOOKABLE = /有房|可订|在架|已核验|已验证|可住|✓|✅/
+    if (HOTEL_ASSERT.test(line) && HOTEL_BOOKABLE.test(line)) {
+      const stays = [...line.matchAll(/(?<!\d)(\d{4}-\d{2}-\d{2})(?!\d)/g)].map(m => m[1]!)
+      claims.hotels.push({
+        line: lineNo,
+        text: line.trim().slice(0, 160),
+        destination: occ1(line, map),
+        check_in: stays[0],
+        check_out: stays[1],
+      })
+    }
     // 航司→机场映射 claim:同一行出现承运码 + 机场码,且该城是双机场映射面
     for (const [city, carriers] of Object.entries(map.carrier_airport)) {
       const airports = [...new Set(Object.values(carriers))]
@@ -207,6 +248,8 @@ export type GateViolationKind =
   | 'legs_inconsistent'               // flight O&D 段与 legs 口径不一致
   | 'budget_floor_inconsistent'       // 预算下限话术低于分项最低合计
   | 'date_order'                      // 住宿/段日期越窗或倒挂
+  | 'unverifiable_hotel_claim'        // 酒店可住断言无 exact-date 事实回溯(D-26)
+  | 'fact_anchor_unknown'             // 渲染锚点 fact:<id> 在注册表不存在(锚点被手改/伪造)
 
 export interface GateViolation {
   kind: GateViolationKind
@@ -242,6 +285,43 @@ export function gateArtifact(
   const violations: GateViolation[] = []
   let traceable = 0
 
+  // 渲染锚点优先(issue #118 单向生成):带 fact:<id> 的行确定性回溯注册表——
+  // 锚点在=按事实 bookability 判;锚点不存在=手改/伪造,直接违例。启发式对锚点行让位。
+  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 !== '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
+    }
+    traceable++
+  }
+
+  // 酒店 claim(D-26):目的地+档期回溯酒店事实;无事实 fail-closed
+  for (const c of claims.hotels) {
+    if (claims.anchors.has(c.line)) continue
+    if (!c.destination) {
+      violations.push({ kind: 'unverifiable_hotel_claim', line: c.line, detail: `酒店可住断言缺目的地上下文,无法回溯 exact-date 事实——fail closed 按未核验处理` })
+      continue
+    }
+    const r = hotelClaimVerdict(facts, { destination: c.destination, check_in: c.check_in, check_out: c.check_out })
+    if (r.verdict === 'traceable') {
+      traceable++
+      continue
+    }
+    if (r.verdict === 'unverified') {
+      violations.push({ kind: 'unverifiable_hotel_claim', line: c.line, detail: r.reason })
+    } else {
+      violations.push({ kind: 'not_in_source', line: c.line, detail: r.reason })
+    }
+    if (CHECK_MARK.test(c.text)) {
+      violations.push({ kind: 'unconditional_check', line: c.line, detail: '对未核验酒店使用无条件 ✓/✅——只有 bookable_exact_date 才允许确定性标记' })
+    }
+  }
+
   for (const c of claims.flights) {
     if (c.carrier_only) {
       // 承运级直飞断言:注册表该 route+date 须存在该承运的 bookable 直飞
@@ -334,7 +414,7 @@ export function gateArtifact(
     if (!line.includes('联程')) return
     const nos = [...line.matchAll(FLIGHT_NO)].map(m => m[1]!.toUpperCase())
     const matched = facts.filter((f): f is Extract<BookableFact, { kind: 'flight' | 'train' }> =>
-      f.kind !== 'policy' && nos.includes(f.flight_no.toUpperCase()))
+      (f.kind === 'flight' || f.kind === 'train') && nos.includes(f.flight_no.toUpperCase()))
     const allProtected = nos.length > 0
       && matched.length === nos.length
       && matched.every(f => f.protected_connection === true)

package/ts/src/benchmark-agent-conformance.ts

@@ -89,12 +89,19 @@ function invalidTerminal(): TerminalOutputValue {
   return { ok: false, error: 'invalid_terminal_output' }
 }
 
+/** 剥离推理模型的思考标签对(如 MiniMax/DeepSeek 的 <think>…</think>):当代模型
+ *  即便被明令「只回终态包」也会以思考块前缀输出——不剥则严格终态门对推理模型
+ *  结构性失效(Round 9 治理面实测)。只剥配对的推理标签本体,其余前后缀仍 fail-closed。 */
+function stripReasoningBlocks(raw: string): string {
+  return raw.replace(/<think>[\s\S]*?<\/think>\s*/gi, '')
+}
+
 /** Parse exactly one configured tag pair containing one JSON object. */
 export function parseBenchmarkTerminal(raw: string, config: TerminalOutputConfig): TerminalOutputValue {
   if (!validateTerminalOutputConfig(config)) return invalidTerminal()
   if (Buffer.byteLength(raw, 'utf8') > config.max_bytes) return invalidTerminal()
 
-  const trimmed = raw.trim()
+  const trimmed = stripReasoningBlocks(raw).trim()
   const opening = `<${config.tag}>`
   const closing = `</${config.tag}>`
   if (!trimmed.startsWith(opening) || !trimmed.endsWith(closing)) return invalidTerminal()
@@ -227,10 +234,11 @@ export function createBenchmarkAgentConformance(projection: BenchmarkBridgeProje
         }
         if (typeof event.data.callId !== 'string') return
         const args = parseToolArguments(event.data.arguments)
-        const query = args && plainObject(args.query) ? args.query : undefined
-        if (query?.action === 'call'
-          && typeof query.tool === 'string'
-          && projection.allowedTools.includes(query.tool)) {
+        // Round 8(issue #100/#102):bridge 工具 typed 泛化后,模型出参为平铺形态
+        const flat = args && plainObject(args) ? args : undefined
+        if (flat?.action === 'call'
+          && typeof flat.tool === 'string'
+          && projection.allowedTools.includes(flat.tool)) {
           state.validCallIds.add(event.data.callId)
         }
         return
@@ -338,7 +346,7 @@ function systemSection(projection: BenchmarkBridgeProjection): { name: string; t
     text: [
       'Benchmark execution contract:',
       `- Translate every task instruction to use a CLI, shell, Python, or agent_env.cli into the native tool ${projection.toolName}; do not merely describe the intended command.`,
-      `- Call it with exactly {"query":{"action":"call","tool":"<one of: ${allowed}>","arguments":{...}}}.`,
+      `- Call it with exactly {"action":"call","tool":"<one of: ${allowed}>","arguments":{...}}.`,
       '- action:"tools" is discovery only and does not satisfy the required environment call.',
       `- After a successful tool result, reply only <${projection.terminal.tag}>{...one JSON object...}</${projection.terminal.tag}> with no prose or code fence.`,
       '- If a terminal-format correction arrives, reuse the existing result and do not call the tool again.',

package/ts/src/benchmark-environment-bridge.ts

@@ -244,6 +244,21 @@ function serializedArguments(value: Record<string, unknown>): { json: string; re
   }
 }
 
+/** 可恢复 domain-error 契约(Round 8,issue #100/#102):封闭词表 + 逐码可恢复性与补救指引。
+ *  模型经 action=errors 拉取全表;失败返回的扁平形状保持不变(benchmark 诊断面依赖)。 */
+export const BRIDGE_ERROR_CONTRACT: Record<string, { recoverable: boolean; remedy: string }> = Object.freeze({
+  invalid_action: { recoverable: true, remedy: 'action 只允许 tools 或 call' },
+  disallowed_tool: { recoverable: true, remedy: '先 action=tools 列出 allowed_tools 清单,再从清单内选工具' },
+  invalid_arguments: { recoverable: true, remedy: 'arguments 必须是可序列化 JSON 对象(≤64KB、深度≤12);收窄后重试' },
+  timed_out: { recoverable: true, remedy: '上游超时;可原样重试一次或换其他工具' },
+  output_truncated: { recoverable: true, remedy: '输出超出上限;让被调工具收窄查询范围后重试' },
+  invalid_json: { recoverable: true, remedy: '上游输出不是合法 JSON;重试一次或换工具' },
+  invalid_output: { recoverable: true, remedy: '上游输出结构不符(如原始字符串);重试或换工具' },
+  runner_failed: { recoverable: true, remedy: '上游进程非零退出;可重试一次,持续失败换工具' },
+  spawn_failed: { recoverable: false, remedy: '可执行文件不可用——环境问题,调用方不可恢复' },
+  forbidden_output: { recoverable: false, remedy: '输出含未授权键(策略边界)——不可恢复,换工具或放弃' },
+})
+
 /** Register the opt-in model-facing bridge. */
 export function registerBenchmarkEnvironmentBridge(
   path: string,
@@ -256,22 +271,26 @@ export function registerBenchmarkEnvironmentBridge(
 
   register(defineTool({
     name: 'gotry_benchmark_environment',
-    description: 'When a prompt asks to run agent_env.cli, use action=call here with the mapped tool; arbitrary shell is not exposed.',
+    description: 'When a prompt asks to run agent_env.cli, use action=call here with the mapped tool; arbitrary shell is not exposed. '
+      + 'Recoverable domain-error contract: every failure returns { ok:false, error:<code>, ... } from a closed vocabulary; '
+      + 'call action=errors to fetch the per-code recoverable flag and remedy before retrying.',
+    // Round 8(issue #100/#102):generic typed schema——模型可见逐字段契约(与产品面 D-30 同刀法);
+    // arguments 保持 additionalProperties:true(被调工具的参数面由其自身契约定义)
     parameters: {
-      query: {
-        type: 'json',
-        required: true,
-        description: '{ action: "tools" | "call", tool?: string, arguments?: object }',
-      },
+      action: { type: 'string', enum: ['tools', 'call', 'errors'], required: true, description: 'tools=列出可调工具;call=执行被映射工具;errors=拉取可恢复错误契约表' },
+      tool: { type: 'string', description: '被调工具名(必须在 allowed_tools 清单内;action=call 时必填)' },
+      arguments: { type: 'object', additionalProperties: true, description: '传给被调工具的参数对象(action=call 时可选;≤64KB、深度≤12)' },
     },
     output: {
       schema: { type: 'json' },
       render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }],
     },
-    async execute(args: { query?: unknown }): Promise<Record<string, never>> {
-      const query = plainObject(args?.query) ? args.query : {}
-      if (query.action === 'tools') return jsonObject({ ok: true, tools: bridge.allowed_tools })
-      if (query.action !== 'call') return jsonObject({ ok: false, error: 'invalid_action' })
+    async execute(args): Promise<Record<string, never>> {
+      const action = args?.action
+      if (action === 'errors') return jsonObject({ ok: true, errors: BRIDGE_ERROR_CONTRACT })
+      if (action === 'tools') return jsonObject({ ok: true, tools: bridge.allowed_tools })
+      if (action !== 'call') return jsonObject({ ok: false, error: 'invalid_action' })
+      const query = args as unknown as { tool?: unknown; arguments?: unknown }
       if (typeof query.tool !== 'string' || !bridge.allowed_tools.includes(query.tool)) {
         return jsonObject({ ok: false, error: 'disallowed_tool' })
       }

package/ts/src/bookable-facts.ts

@@ -89,7 +89,34 @@ export interface PolicyFact {
   review_by?: string
 }
 
-export type BookableFact = FlightFact | PolicyFact
+export type BookableFact = FlightFact | PolicyFact | HotelFact
+
+/**
+ * 酒店事实(D-26,issue #118):exact-date 酒店检索(hit/miss)的唯一事实形态。
+ * 纪律与机/火同源:①未定档期的摸底检索不落账(无 exact-date 语义);
+ * ②needs-setup/error 是传输失败,永不落负事实;③价格上游打码(¥7xx)——
+ * 本事实**不落数字价**,只记在架家数,真实价以落地页为准(打码价保真纪律)。
+ */
+export interface HotelFact {
+  schema: typeof BOOKABLE_FACT_SCHEMA
+  /** 语义派生 id:sha(destination|checkIn|checkOut|query_id)——同查询重放幂等 */
+  fact_id: string
+  kind: 'hotel'
+  /** 目的地中文(flyai/session 的 to;闸侧 claim 匹配键) */
+  destination: string
+  check_in?: string   // YYYY-MM-DD
+  check_out?: string  // YYYY-MM-DD
+  verdict: 'hit' | 'miss'
+  bookability: Bookability
+  /** 在架条数(hit 时;价格打码不落数字价) */
+  options_masked: number
+  source: string      // flyai-hotel / session:ctrip-hotel
+  /** 可重放查询 id(如 flyai:hotel:大理:2026-10-01_2026-10-03) */
+  query_id: string
+  fetched_at: string
+  as_of: string
+  tier: EvidenceTier
+}
 
 // ---------------------------------------------------------------------------
 // id 与查询词(可重放:query_id 即重放凭证)
@@ -133,7 +160,8 @@ export interface FlyaiLikeOption {
 }
 
 export interface FlyaiLikeResult {
-  verdict: 'hit' | 'miss' | 'error'
+  /** needs-setup(试用额度达限)同 error:无结论不是证据,不落事实 */
+  verdict: 'hit' | 'miss' | 'error' | 'needs-setup'
   options?: FlyaiLikeOption[]
   evidence?: string
 }
@@ -190,7 +218,7 @@ export function factsFromFlyai(q: { kind: 'flight' | 'train'; origin: string; de
   const queryId = makeQueryId(source, q.kind, q.origin, q.destination, q.date)
   const origin = iataOf(alias, q.origin)
   const destination = iataOf(alias, q.destination)
-  if (r.verdict === 'error') return []
+  if (r.verdict === 'error' || r.verdict === 'needs-setup') return []
   if (r.verdict === 'miss') return [negativeFact(queryId, q.kind, q.origin, q.destination, q.date, source, fetchedAt, alias)]
   const facts: FlightFact[] = []
   for (const o of r.options ?? []) {
@@ -278,7 +306,7 @@ export function dedupeFacts<T extends BookableFact>(facts: T[]): T[] {
 /** route+date 的最新查询结论(同日多次查询:最新一次为准,避免「昨天 miss 今天 hit」陈旧否定) */
 export function latestFactsForRouteDate(facts: BookableFact[], origin: string, destination: string, date: string): FlightFact[] {
   const hits = facts.filter((f): f is FlightFact =>
-    f.kind !== 'policy'
+    (f.kind === 'flight' || f.kind === 'train')
     && f.route.origin === origin && f.route.destination === destination && f.date === date)
   const latestQueryTs = new Map<string, string>()
   for (const f of hits) {
@@ -310,7 +338,7 @@ export interface FlightClaim {
 export function flightClaimVerdict(facts: BookableFact[], claim: FlightClaim): { verdict: FlightClaimVerdict; fact?: FlightFact; reason: string } {
   const no = claim.flight_no.toUpperCase().replace(/\s+/g, '')
   const sameNo = facts.filter((f): f is FlightFact =>
-    f.kind !== 'policy' && f.flight_no.toUpperCase() === no && f.bookability === 'bookable_exact_date')
+    (f.kind === 'flight' || f.kind === 'train') && f.flight_no.toUpperCase() === no && f.bookability === 'bookable_exact_date')
   const routeMatched = sameNo.filter(f =>
     (!claim.origin || f.route.origin === claim.origin || f.route.origin_airport === claim.origin)
     && (!claim.destination || f.route.destination === claim.destination || f.route.dest_airport === claim.destination)
@@ -502,6 +530,12 @@ export function defaultReviewBy(tripDate: string): string {
  * 永不输出无条件 ✓;证据链(source/query_id/fetched_at)随行必达。
  */
 export function renderFlightFact(f: FlightFact): string {
+  return renderFlightFactInner(f) + ` <!-- fact:${f.fact_id} -->`
+}
+
+function renderFlightFactInner(f: FlightFact): string {
+  // 单向生成锚点(D-26):每条事实行内嵌 fact_id,闸侧锚点匹配 = 确定性回溯
+  const anchor = ` <!-- fact:${f.fact_id} -->`
   const route = `${f.route.origin}→${f.route.destination}`
   const evidence = `[${f.source}@${f.fetched_at} #${f.query_id}]`
   if (f.bookability === 'unavailable_exact_date') {
@@ -555,3 +589,73 @@ export function renderNightsLine(it: ItineraryFacts): string {
   const flightLegs = it.od_segments.filter(s => s.mode === 'flight').reduce((acc, s) => acc + s.legs, 0)
   return `共 ${daysBetween(it.trip_start, it.trip_end) + 1} 天 ${totalNights} 晚 = ${hotelNights} 个酒店夜 + ${it.onboard_nights} 个机上夜;航班按 O&D ${flightOd} 段(共 ${flightLegs} 个 flight legs)`
 }
+
+// ---------------------------------------------------------------------------
+// 酒店事实(D-26,issue #118):exact-date 酒店检索 hit/miss 落账
+// 纪律:摸底(未定档期)不落账(无 exact-date 语义);needs-setup/error 传输失败永不落负事实
+// ---------------------------------------------------------------------------
+
+export function factsFromHotel(input: {
+  source: string
+  destination: string
+  checkIn?: string
+  checkOut?: string
+  verdict: 'hit' | 'miss' | 'needs-setup' | 'error'
+  options: number
+  evidence: string
+  fetchedAt: string
+}): HotelFact[] {
+  if (!input.checkIn || !input.checkOut) return []
+  if (input.verdict !== 'hit' && input.verdict !== 'miss') return []
+  const queryId = `hotel:${input.source}:${input.destination}:${input.checkIn}_${input.checkOut}`
+  return [{
+    schema: BOOKABLE_FACT_SCHEMA,
+    kind: 'hotel',
+    fact_id: makeFactId([input.destination, input.checkIn, input.checkOut, queryId]),
+    destination: input.destination,
+    check_in: input.checkIn,
+    check_out: input.checkOut,
+    verdict: input.verdict,
+    bookability: input.verdict === 'hit' ? 'bookable_exact_date' : 'unavailable_exact_date',
+    options_masked: input.options,
+    source: input.source,
+    query_id: queryId,
+    fetched_at: input.fetchedAt,
+    as_of: input.fetchedAt.slice(0, 10),
+    tier: 'live_inventory',
+  }]
+}
+
+/** 酒店 claim 回溯:同目的地+同档期的 exact-date 事实裁决(无事实=unverified,fail-closed) */
+export function hotelClaimVerdict(
+  facts: BookableFact[],
+  claim: { destination: string; check_in?: string; check_out?: string },
+): { verdict: 'traceable' | 'not_in_source' | 'unverified'; fact?: HotelFact; reason: string } {
+  const scoped = facts.filter((f): f is HotelFact =>
+    f.kind === 'hotel' && f.destination === claim.destination
+    && (!claim.check_in || f.check_in === claim.check_in)
+    && (!claim.check_out || f.check_out === claim.check_out))
+  if (scoped.length === 0) {
+    return {
+      verdict: 'unverified',
+      reason: `酒店 claim(${claim.destination}${claim.check_in ? ` ${claim.check_in}→${claim.check_out ?? '?'}` : ''})未经 exact-date 源核验——先检索再写结论`,
+    }
+  }
+  const hit = scoped.find(f => f.bookability === 'bookable_exact_date')
+  if (hit) return { verdict: 'traceable', fact: hit, reason: 'exact-date 命中' }
+  const latest = scoped[scoped.length - 1]!
+  return { verdict: 'not_in_source', fact: latest, reason: `该档期 exact-date 源正常返回 0 条(${latest.fetched_at})——不得写有房/可订` }
+}
+
+// ---------------------------------------------------------------------------
+// 渲染原语(单向生成,issue #118):事实 → 行,锚点内嵌 fact_id;
+// 产物经原语渲染即自带溯源锚,闸侧锚点匹配 = 确定性回溯,不靠行文猜测
+// ---------------------------------------------------------------------------
+
+
+export function renderHotelFact(f: HotelFact): string {
+  if (f.verdict !== 'hit') {
+    return `- ${f.destination} ${f.check_in}→${f.check_out}:exact-date 源 0 条在架(不可订) <!-- fact:${f.fact_id} -->`
+  }
+  return `- ${f.destination} ${f.check_in}→${f.check_out}:住宿已核验(在架 ${f.options_masked} 家;价格上游打码,真实价以落地页为准) <!-- fact:${f.fact_id} -->`
+}

package/ts/src/booking-saga.ts

@@ -1,7 +1,7 @@
 /**
  * 预订 saga 状态机(booking_saga_fsm.v1)——issue #17 采纳三点的具名化落点。
  *
- * 立场(docs/booking-saga-fsm.md / ADR-17):不引入编排框架;预订 saga 的状态字母表与边表
+ * 立场(docs/design/booking-saga-fsm.md / ADR-17):不引入编排框架;预订 saga 的状态字母表与边表
  * 就是账本 pending_writes(status CHECK:pending|confirmed|compensated)的显式化。
  * 本模块是纯函数词汇层,零依赖、零行为、不接线任何 seam——M5 拍板 WriteGate 生产化时
  * 以此为唯一状态推进词汇(具名化 = 状态与边不再散落在 SQL 字符串里)。