@danceiny/gotry 0.0.1-rc.5

package/ts/src/loop.ts

@@ -0,0 +1,336 @@
+/**
+ * Stage 1 对话循环(S2 段1,docs/stage1-top-down-design.md §2.3)。
+ *
+ * 自顶向下:循环只依赖两个端口——LlmPort(mock/真)与确定性工具(interview_next)。
+ * 求解/渲染接线是 S2 后续段;本段验收:重放用户开场白,系统一轮内完成
+ * 日历断言 + 访谈补全启动(问出工作窗口与已订资源——Kimi 第 6 轮才问的事)。
+ */
+
+import type { InterviewQuestion, TripState, TravelerProfile, Turn, CalendarState, SolveResult } from './contracts.ts'
+import type { JourneySpecTS } from './unified.ts'
+import { anythingSearch } from '../capabilities/anything.ts'
+
+/** LLM 端口:S2 mock(确定性剧本) / S4 真(dsh 运行时)。循环不感知差异。 */
+export interface LlmPort {
+  /** 从对话抽取事实:日历(年/星期)与 profile 字段,带 evidence */
+  extractFacts(history: Turn[], state: TripState): Promise<{
+    calendar?: Partial<CalendarState>
+    profile?: Partial<TravelerProfile>
+    assumptions: Array<{ field: string; source: 'user-verbatim' | 'inferred' | 'default' }>
+  }>
+  /** 翻译:对话历史 → 统一模型 spec;约束未齐时返回 null(循环继续访谈) */
+  extractSpec(history: Turn[], state: TripState): Promise<JourneySpecTS | null>
+  /** 问句润色(ADR-9:确定性驱动,LLM 只管语气) */
+  polishQuestion(q: InterviewQuestion): Promise<string>
+  /** 结果解释(S3 接 solve 后启用) */
+  render?(state: TripState): Promise<string>
+}
+
+export function newState(year = 2026): TripState {
+  return {
+    calendar: { year, assertedWeekdays: {} },
+    profile: {},
+    gates: [],
+    wishes: [],
+  }
+}
+
+/** ADR-9:访谈由缺失字段驱动(确定性,无 LLM 即兴) */
+export function interviewNext(state: TripState): { questions: InterviewQuestion[]; missing: string[] } {
+  const p = state.profile
+  const questions: InterviewQuestion[] = []
+  const ww = p.workWindow as unknown as { vacation?: boolean } | undefined
+  if (!p.workWindow && !ww?.vacation) {
+    questions.push({
+      key: 'workWindow',
+      text: '你这两周要远程办公——工作时间是几点到几点、按哪个时区?这决定每天的可玩时段。',
+      why: '工作窗口直接决定每日节奏(普吉 13:00-22:00 与 9:00-18:00 是两种人生)',
+    })
+  }
+  if (!p.bookedResources) {
+    questions.push({
+      key: 'bookedResources',
+      text: '已经有订好的航班或酒店吗?(哪怕只是意向)——已订资源是硬锚点,先告诉我再规划。',
+      why: '已订资源决定哪些段不可动,Kimi 式规划会绕开它们重排',
+    })
+  }
+  if (!p.budgetTier) {
+    questions.push({
+      key: 'budgetTier',
+      text: '预算档位:经济(¥12.6k 级)/ 舒适(¥16.3k 级)/ 便利优先?',
+      why: '分层预算决定班次与住宿的选型口径',
+      options: [
+        { label: '经济', tradeOff: '省钱,接驳多走路' },
+        { label: '舒适', tradeOff: 'workation 办公质量优先' },
+        { label: '便利优先', tradeOff: '时间最省' },
+      ],
+    })
+  }
+  return { questions, missing: questions.map(q => q.key) }
+}
+
+/** spec 校验闸:LLM 翻译产物进求解器前的确定性形状检查(责任边界的执行点)。 */
+export function validateSpec(spec: JourneySpecTS): string | null {
+  if (!Array.isArray(spec.segments) || spec.segments.length === 0) return '没有段(segments)'
+  for (const seg of spec.segments) {
+    if (!seg.id) return '存在缺少 id 的段'
+    if (!Array.isArray(seg.options) || seg.options.length === 0) return `段 ${seg.id} 没有可选方案`
+    for (const opt of seg.options) {
+      const svcs = opt.move?.services
+      if (!Array.isArray(svcs) || svcs.length === 0) return `段 ${seg.id} 的方案 ${opt.id} 缺少班次(services)`
+      for (const s of svcs) {
+        if (typeof s.depMin !== 'number' || typeof s.arrMin !== 'number') {
+          return `段 ${seg.id}/${opt.id} 的班次 ${s.id ?? '?'} 缺少时刻(depMin/arrMin)`
+        }
+      }
+    }
+  }
+  return null
+}
+
+/** 求解端口:S3 起由 unified 求解器实现;循环只认此签名(确定性责任)。 */
+export type SolvePort = (spec: JourneySpecTS) => Promise<SolveResult>
+
+// ---- 异步深度规划(S5 架构段,ADR-8:编排架构先于智能) ----------------------------
+// 产品形态:复杂规划 → 「我后台做,约一小时后回来看看」→ 回访时交付
+// 已验证方案 + 选择题。不失望四条是交付物的自检契约。
+
+export interface AsyncTicket {
+  id: string
+  objective: string
+  requestedAt: string
+  /** 剧本/mock 期用分钟级;真实化(S5 后半段)由 loopx tick 驱动 */
+  etaLabel: string
+}
+
+export function isComplex(state: TripState): boolean {
+  /** 复杂度判据(架构占位,后续可细化):多段或多约束即深规划 */
+  const p = state.profile
+  return Boolean(p.workWindow && p.bookedResources) && (state.gates.length > 0 || Boolean(state.spec))
+}
+
+export async function requestDeepPlanning(state: TripState): Promise<{ reply: string; ticket: AsyncTicket }> {
+  const ticket: AsyncTicket = {
+    id: `dp-${Date.now().toString(36)}`,
+    objective: '生成已验证的行程方案:全成本核算 + 动机/约束匹配 + 不失望四条',
+    requestedAt: new Date().toISOString(),
+    etaLabel: '约 1 小时(mock 期:秒级)',
+  }
+  state.gates.push({ id: `async-${ticket.id}`, question: `深度规划已启动(${ticket.etaLabel})`, options: [] })
+  const reply = '这趟行程跨度大(两周 workation + 三城 + 红眼返程),我切到**深度规划模式**:后台做多轮校验'
+    + '(锚点/工作窗口/全成本/负例排查),做好后通知你。**先留一道选择题给你**,回来直接定:'
+    + '\n1. 预算档位?(经济/舒适/便利优先)'
+  return { reply, ticket }
+}
+
+export async function collectDeepPlanning(
+  state: TripState,
+  ticket: AsyncTicket,
+  solve: SolvePort,
+): Promise<{ reply: string; state: TripState }> {
+  const spec = state.spec
+  if (!spec) return { reply: '(内部状态缺失 spec——深度规划未就绪,这是不应发生的路径)', state }
+  state.solve = await solve(spec)
+  state.gates = state.gates.filter(g => !g.id.startsWith('async-'))
+
+  // 不失望四条自检(交付物自带,总纲 3.6)
+  const checks = {
+    '1_承诺时间后必有明确产物': Boolean(state.solve.legs?.length || state.solve.verdicts?.length),
+    '2_产物通过自检清单': state.solve.feasible ? (state.solve.legs?.every(l => (l as Record<string, unknown>)['energy_pct'] !== undefined) ?? false) : Boolean(state.solve.unsat_core?.length),
+    '3_待决问题全部是简单选择题': state.gates.every(g => g.id === 'budget' || g.options.length >= 2),
+    '4_做不到的诚实说': state.solve.feasible || Boolean(state.solve.suggestions?.length),
+  }
+  const head = `# 回访交付:${ticket.objective}\n(工单 ${ticket.id},不失望四条:${Object.values(checks).every(Boolean) ? '4/4 ✅' : '有未达项 ❌'})`
+  return { reply: `${head}\n\n${renderSolve(state)}`, state }
+}
+
+/** 求解结果 → 人话(模板;S4 可由 LLM 润色,数字与判定不可改) */
+export function renderSolve(state: TripState): string {
+  const s = state.solve
+  if (!s) return '(无求解结果)'
+  const lines: string[] = []
+  if (s.feasible) {
+    lines.push(`**方案可行,机票合计 ¥${s.money_cny}**`)
+    for (const lg of s.legs ?? []) {
+      const l = lg as Record<string, string | number>
+      lines.push(`- ${l['leg']} ${l['service']}:${l['dep']} 起飞,${l['wake']} 出发,${l['arrive_stay']} 到,`
+        + `门到门 ${l['door_to_door']},落地精力 ${l['energy_pct']}%,¥${l['price_cny']}`)
+    }
+    for (const e of s.work_window_exclusions ?? []) {
+      lines.push(`- 已排除 ${e.option}(工作窗口):${e.reason}`)
+    }
+    for (const n of s.skeleton_notes ?? []) lines.push(`- ${n}`)
+    for (const f of s.red_flags ?? []) lines.push(`- ⚠️ ${f}`)
+  } else {
+    lines.push(`**当前约束下不可行——冲突:${(s.unsat_core ?? []).join('、')}`)
+    for (const sg of s.suggestions ?? []) lines.push(`- 放宽「${sg.relax}」可解(约 ¥${sg.money_cny})`)
+  }
+  if (state.gates.length) {
+    lines.push('', '**待你决定(选择题)**')
+    for (const g of state.gates) {
+      lines.push(`- ${g.question} → ${g.options.map(o => o.label + (o.tradeOff ? `(${o.tradeOff})` : '')).join(' / ')}`)
+    }
+  }
+  return lines.join('\n')
+}
+
+/** 一次对话回合:抽取事实(冲突即指出)→ 增量访谈 → 约束齐备则求解+渲染。 */
+export async function runTurn(
+  state: TripState,
+  userMsg: string,
+  llm: LlmPort,
+  history: Turn[] = [],
+  solve: SolvePort | null = null,
+): Promise<{ reply: string; state: TripState }> {
+  const facts = await llm.extractFacts([...history, { role: 'user', text: userMsg }], state)
+
+  const conflicts: string[] = []
+  if (facts.calendar?.assertedWeekdays) {
+    for (const [date, wd] of Object.entries(facts.calendar.assertedWeekdays)) {
+      const prev = state.calendar.assertedWeekdays[date]
+      if (prev && prev !== wd) {
+        conflicts.push(`${date}:已有断言 ${prev},新说法 ${wd}——以先断言为准,如需改请明确说`)
+      } else {
+        state.calendar.assertedWeekdays[date] = wd
+      }
+    }
+  }
+  Object.assign(state.profile, facts.profile ?? {})
+
+  // 访谈:workWindow/bookedResources 是求解前置;budgetTier 转为 gate(不阻塞规划)
+  const { questions } = interviewNext(state)
+  const blocking = questions.filter(q => q.key !== 'budgetTier')
+  const budgetQ = questions.find(q => q.key === 'budgetTier')
+  if (budgetQ && !state.gates.some(g => g.id === 'budget')) {
+    state.gates.push({
+      id: 'budget',
+      question: budgetQ.text,
+      options: budgetQ.options ?? [{ label: '经济' }, { label: '舒适' }, { label: '便利优先' }],
+    })
+  }
+
+  const parts: string[] = []
+  if (conflicts.length) parts.push(`⚠️ 日历冲突:\n${conflicts.map(c => `- ${c}`).join('\n')}`)
+
+  // D-7a 例外: blocking>0 时,用户消息含"查+地名/酒店/天气"信号时,直接调 anything_search
+  // 走 PoI 真相(datasources 层主动调,不动 polling 状态机,不改求解器)
+  const poiProbe = probePoi(userMsg)
+  if (poiProbe) {
+    const ar = await anythingSearch({ keyword: poiProbe })
+    if (ar.verdict === 'hit' && ar.hits && ar.hits.length > 0) {
+      const top = ar.hits.slice(0, 5)
+      const lines = top.map((h, i) => {
+        const latlng = h.latitude !== undefined && h.longitude !== undefined
+          ? ` @ (${h.latitude.toFixed(3)},${h.longitude.toFixed(3)})`
+          : ''
+        return `  ${i + 1}. [${h.type}] ${h.name}${latlng}`
+      }).join('\n')
+      parts.push(`**${poiProbe} → hit (${ar.hits.length} 候选项)**\n${lines}\n${ar.evidence}`)
+    } else if (ar.verdict === 'miss') {
+      parts.push(`**${poiProbe} → miss** (酒店-be Anything 一切正常但无候选)\n${ar.evidence}`)
+    } else {
+      parts.push(`**${poiProbe} → unavailable** (${ar.error ?? 'hbcli 不可达'})\n${ar.evidence}`)
+    }
+  }
+
+  for (const q of blocking) parts.push(await llm.polishQuestion(q))
+
+  // 约束齐备(无阻塞问题)→ 翻译 spec → **校验闸** → 求解 → 渲染
+  if (blocking.length === 0 && solve) {
+    const spec = await llm.extractSpec([...history, { role: 'user', text: userMsg }], state)
+    // 场景路由:erhai 候选标记 → 候选求解(洱海金标准的引擎判定)——纯 TS unify 路径
+    if (spec && (spec as unknown as { note?: string }).note === 'erhai-candidates') {
+      const { readFile } = await import('node:fs/promises')
+      const { join } = await import('node:path')
+      try {
+        const raw = JSON.parse(await readFile(join(import.meta.dirname, '..', '..', 'data', 'golden_erhai.json'), 'utf-8'))
+        const { parseCandidate, parseRequest } = await import('./model.ts')
+        const { segmentsFromCandidate, solveChoiceSegment } = await import('./unified.ts')
+        const req = parseRequest(raw['request'] as Record<string, unknown>)
+        const cands = (raw['candidates'] as Record<string, unknown>[]).map(parseCandidate)
+        const erhaiSpec = segmentsFromCandidate(req, cands)
+        const result = solveChoiceSegment(erhaiSpec, req) as { answer_md?: string; recommended?: string }
+        state.solve = result as never
+        parts.push(result.answer_md ?? '(候选求解完成)')
+      } catch {
+        parts.push('(洱海候选求解暂不可用——退回访谈)')
+      }
+    } else {
+      const invalid = spec ? validateSpec(spec) : '翻译器未产出 spec'
+      if (spec && !invalid) {
+        state.spec = spec
+        state.solve = await solve(spec)
+        parts.push(llm.render ? await llm.render(state) : renderSolve(state))
+      } else if (blocking.length === 0 && invalid) {
+        parts.push(`(行程骨架还不完整:${invalid}——请补充对应信息,我不猜)`)
+      }
+    }
+  } else if (blocking.length === 0) {
+    parts.push('(约束齐备——进入规划,S3 接线后此处产出方案与选择题)')
+  }
+  return { reply: parts.join('\n\n'), state }
+}
+
+// ---- 异步工单持久化(S5 编排半段):真正的「一小时后」必须跨进程存续 ----
+// 请求时落盘(ticket+state 快照);任意后续进程(如 loopx 驱动的 tick)执行
+// async-collect 加载、求解、写回交付物。状态目录属用户数据(红线 6)。
+
+import { join } from 'node:path'
+import { mkdir } from 'node:fs/promises'
+import { readFile, writeFile } from 'node:fs/promises'
+
+const ASYNC_DIR = 'gotry-state/async'
+
+async function asyncPath(name: string): Promise<string> {
+  await mkdir(ASYNC_DIR, { recursive: true })
+  return join(ASYNC_DIR, name)
+}
+
+export async function persistAsyncTicket(ticket: AsyncTicket, state: TripState): Promise<string> {
+  const p = await asyncPath(`${ticket.id}.json`)
+  await writeFile(p, JSON.stringify({ ticket, state }, null, 2), 'utf-8')
+  return p
+}
+
+export async function loadAsyncTicket(ticketId: string): Promise<{ ticket: AsyncTicket; state: TripState } | null> {
+  try {
+    const p = await asyncPath(`${ticketId}.json`)
+    return JSON.parse(await readFile(p, 'utf-8')) as { ticket: AsyncTicket; state: TripState }
+  } catch {
+    return null
+  }
+}
+
+export async function settleAsyncTicket(ticketId: string, reply: string): Promise<string> {
+  const p = await asyncPath(`${ticketId}.deliverable.md`)
+  await writeFile(p, reply, 'utf-8')
+  return p
+}
+
+/**
+ * probePoi:从 user msg 探测"查 POI/酒店" 信号,返回关键词。
+ * 触发的不是关键词,是**结构**:句首含"查/搜/找" + 后接地理/酒店类名词。
+ * 不是意图(改求解器),只是 datasources 编排层的"提早调 anything"提示。
+ */
+export function probePoi(msg: string): string | null {
+  const trimmed = msg.trim()
+  if (!trimmed) return null
+  // 短查询(<=24 字符 且非问句): 优先剥 trigger 词,再 fall-through 让内容触发也跑
+  const isShort = trimmed.length <= 24 && !/[?？!！。.,，]/.test(trimmed)
+  if (isShort) {
+    const stripped = trimmed.replace(/^(查一下|查|搜|找|看看|推荐|告诉我|检索)\s*/, '').trim()
+    // 即使没 trigger 词,只要 stripped 仍是 ≥2 字符的非空串就当关键词
+    if (stripped.length >= 2) return stripped.slice(0, 24)
+  }
+  // 触发模式:查/搜/找/看看/推荐/告诉我/检索 + 地理/酒店类名词(贪吃但只切前 24 字符)
+  const m = trimmed.match(/(查一下|查|搜|找|看看|推荐|告诉我|检索)\s*(.{2,24})/)
+  if (m) return m[2].trim().slice(0, 24)
+  // 另一模式:含"酒店"/"民宿"/"客栈" 触发酒店查
+  if (/(酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/.test(trimmed)) {
+    // 尝试提取前面的地名关键词
+    const place = trimmed.match(/([一-龥a-zA-Z]{2,12})\s*(?:酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/)
+    if (place) return place[1]
+    return trimmed.replace(/(酒店|民宿|客栈|饭店|有什么|玩什么|有哪些)/, '').trim().slice(0, 24) || trimmed.slice(0, 24)
+  }
+  return null
+}

package/ts/src/mock-llm.ts

@@ -0,0 +1,88 @@
+/**
+ * Mock LLM(S2,ADR-8):确定性剧本,重放真实对话的智能侧。
+ * 它不做任何「聪明事」——只按剧本返回抽取结果;循环架构的正确性由此验证,
+ * 与智能质量解耦。S4 接真 LLM 后,本文件留作回归夹具。
+ */
+
+import type { LlmPort } from './loop.ts'
+import type { InterviewQuestion, TravelerProfile, TripState, Turn, CalendarState } from './contracts.ts'
+import type { JourneySpecTS } from './unified.ts'
+import { parseFlightPackToSpec } from './unified.ts'
+
+interface ScriptStep {
+  /** 命中条件:用户消息包含此关键词(第一条匹配生效) */
+  when: string
+  calendar?: Partial<CalendarState>
+  profile?: Partial<TravelerProfile>
+}
+
+/** 剧本:来自真实 Kimi 对话里用户给出关键事实的时刻 */
+const SCRIPT: ScriptStep[] = [
+  {
+    when: '请给我做机票和酒店的行程规划和推荐',
+    calendar: {
+      year: 2026,
+      assertedWeekdays: {
+        '2026-07-17': 'fri', '2026-07-18': 'sat', '2026-07-31': 'fri',
+        '2026-08-01': 'sat', '2026-08-09': 'sun', '2026-08-10': 'mon',
+      },
+    },
+    profile: { companions: ['girlfriend(先在普吉)'] },
+  },
+  {
+    when: '工作时间',
+    profile: {
+      workWindow: {
+        homeTzOffsetMin: 240, startMin: 600, endMin: 1140, workdays: [0, 1, 2, 3, 4],
+        evidence: '用户原话:我的工作时间是UTC+4的早上10点到下午7点',
+      },
+    },
+  },
+  {
+    when: '订了酒店',
+    profile: {
+      bookedResources: [
+        { kind: 'hotel', ref: 'The Title East Wing Rawai(7.18-23, 5 晚)', window: '2026-07-18~07-23' },
+      ],
+    },
+  },
+]
+
+export function createMockLlm(flightPackPath?: string): LlmPort {
+  let stepIdx = 0
+  return {
+    async extractFacts(history: Turn[], _state: TripState) {
+      const last = history[history.length - 1]?.text ?? ''
+      // 剧本顺序消费:真实对话里事实按此顺序浮出;未命中则无新事实
+      const step = SCRIPT[stepIdx]
+      if (step && last.includes(step.when)) {
+        stepIdx++
+        return {
+          calendar: step.calendar,
+          profile: step.profile,
+          assumptions: Object.keys({ ...step.profile }).map(f => ({ field: f, source: 'user-verbatim' as const })),
+        }
+      }
+      return { assumptions: [] }
+    },
+    async extractSpec(history: Turn[], state: TripState): Promise<JourneySpecTS | null> {
+      // mock 翻译:工作窗口与已订资源齐备后,「翻译」= 装载航班包并挂上真实工作窗口
+      if (!state.profile.workWindow || !state.profile.bookedResources) return null
+      if (!flightPackPath) return null
+      const { readFile } = await import('node:fs/promises')
+      const pack = JSON.parse(await readFile(flightPackPath, 'utf-8'))
+      const spec = parseFlightPackToSpec(pack)
+      spec.workWindow = {
+        homeTzOffsetMin: state.profile.workWindow.homeTzOffsetMin,
+        startMin: state.profile.workWindow.startMin,
+        endMin: state.profile.workWindow.endMin,
+        workdays: state.profile.workWindow.workdays,
+      }
+      spec.budgetCny = 9000
+      return spec
+    },
+    async polishQuestion(q: InterviewQuestion) {
+      return `【${q.key}】${q.text}\n(为什么问:${q.why})`
+    },
+  }
+}

package/ts/src/model.ts

@@ -0,0 +1,220 @@
+/**
+ * Gotry 可行性引擎领域模型(TS 版,与 py/gotry_feasibility/model.py 逐行对齐)。
+ *
+ * 双实现纪律:Python 版是**对照实现(oracle)**,TS 版是产品运行时实现;
+ * 同一输入两版必须给出相同判定(ts/scripts/diff-test.ts 做差分验证)。
+ * 算术(门到门全成本)在此层与求解完全分离,两边各自可测。
+ */
+
+export function hhmmToMin(s: string): number {
+  const [h, m] = s.split(':')
+  return Number(h) * 60 + Number(m)
+}
+
+export function minToHhmm(m: number): string {
+  return `${String(Math.floor(m / 60)).padStart(2, '0')}:${String(m % 60).padStart(2, '0')}`
+}
+
+export interface TransferMode {
+  mode: string
+  minutes: number
+  priceCny: number
+}
+
+export interface Service {
+  id: string
+  depMin: number
+  arrMin: number
+  priceCny: number
+}
+
+export interface HubAccess {
+  hub: string
+  toHubMin: number
+}
+
+export interface MotivationProfile {
+  /** 动机谱系,如 { escape_rest: 0.7, curiosity: 0.3 } */
+  weights: Record<string, number>
+  /** 起床不早于(当日分钟)——由动机推出的硬约束 */
+  wakeFloorMin: number
+  minArrivalEnergyPct: number
+  baseUsableHours: number
+  escapeHoursPerWeight: number
+}
+
+export interface Candidate {
+  id: string
+  name: string
+  hub: string
+  bufferOutMin: number
+  bufferRetMin: number
+  servicesOut: Service[]
+  servicesRet: Service[]
+  destTransfers: TransferMode[]
+  stayCnyPerNight: number
+  localDailyCny: number
+  minDaysForPurpose: number
+  imageryMatch: number
+  bestMonths: number[]
+}
+
+export interface TravelRequest {
+  note: string
+  motivation: MotivationProfile
+  windowDays: number
+  budgetCny: number
+  homeHubAccess: Record<string, HubAccess>
+}
+
+export interface Choice {
+  outService: Service
+  outTransfer: TransferMode
+  retService: Service
+  retTransfer: TransferMode
+  days: number
+}
+
+export interface TrueCost {
+  moneyCny: number
+  wakeMin: number
+  arriveStayMin: number
+  doorToDoorOutMin: number
+  energyArrivalPct: number
+  usableHours: number
+  usableDay1Hours: number
+  usableDay2Hours: number
+  departHomeRetMin: number
+  arriveHomeRetMin: number
+}
+
+export function requiredUsableHours(mot: MotivationProfile): number {
+  return mot.baseUsableHours + mot.escapeHoursPerWeight * (mot.weights['escape_rest'] ?? 0)
+}
+
+// ---- 精力模型(可校准参数,与 Python 版一致) --------------------------------
+export const WAKE_PENALTY_BEFORE_5 = 30
+export const WAKE_PENALTY_BEFORE_6 = 25
+export const WAKE_PENALTY_BEFORE_630 = 15
+export const TRANSFER_PENALTY = 8
+export const LATE_ARRIVAL_PENALTY = 10
+export const LONG_D2D_PENALTY = 10
+export const DAY_END_MIN = 21 * 60
+export const DAY2_START_MIN = 9 * 60
+export const DAY2_QUALITY = 0.9
+export const LATEST_ARRIVE_STAY_MIN = 18 * 60
+
+export function parseMotivation(d: Record<string, unknown>): MotivationProfile {
+  const hard = (d['hard'] ?? {}) as Record<string, unknown>
+  const rawWeights = (d['weights'] ?? d) as Record<string, unknown>
+  const weights: Record<string, number> = {}
+  for (const [k, v] of Object.entries(rawWeights)) {
+    if (typeof v === 'number') weights[k] = v
+  }
+  return {
+    weights,
+    wakeFloorMin: hhmmToMin(String(hard['wake_not_before'] ?? '06:30')),
+    minArrivalEnergyPct: Number(hard['min_arrival_energy_pct'] ?? 40),
+    baseUsableHours: 4.0,
+    escapeHoursPerWeight: 2.0,
+  }
+}
+
+export function parseRequest(d: Record<string, unknown>): TravelRequest {
+  const home = ((d['home'] ?? {}) as Record<string, unknown>)['hubs'] as Record<string, Record<string, unknown>> | undefined ?? {}
+  const homeHubAccess: Record<string, HubAccess> = {}
+  for (const [hub, acc] of Object.entries(home)) {
+    homeHubAccess[hub] = { hub, toHubMin: Number(acc['to_hub_min']) }
+  }
+  return {
+    note: String(d['note'] ?? ''),
+    motivation: parseMotivation(d['motivation'] as Record<string, unknown>),
+    windowDays: Number(d['window_days']),
+    budgetCny: Number(d['budget_cny']),
+    homeHubAccess,
+  }
+}
+
+function parseService(d: Record<string, unknown>): Service {
+  return { id: String(d['id']), depMin: hhmmToMin(String(d['dep'])), arrMin: hhmmToMin(String(d['arr'])), priceCny: Number(d['price_cny']) }
+}
+
+function parseTransfer(d: Record<string, unknown>): TransferMode {
+  return { mode: String(d['mode']), minutes: Number(d['min']), priceCny: Number(d['price_cny']) }
+}
+
+export function parseCandidate(d: Record<string, unknown>): Candidate {
+  return {
+    id: String(d['id']),
+    name: String(d['name']),
+    hub: String(d['hub']),
+    bufferOutMin: Number(d['buffer_out_min'] ?? 60),
+    bufferRetMin: Number(d['buffer_ret_min'] ?? 60),
+    servicesOut: (d['services_out'] as Record<string, unknown>[]).map(parseService),
+    servicesRet: (d['services_ret'] as Record<string, unknown>[]).map(parseService),
+    destTransfers: (d['dest_transfers'] as Record<string, unknown>[]).map(parseTransfer),
+    stayCnyPerNight: Number(d['stay_cny_per_night']),
+    localDailyCny: Number(d['local_daily_cny']),
+    minDaysForPurpose: Number(d['min_days_for_purpose']),
+    imageryMatch: Number(d['imagery_match']),
+    bestMonths: ((d['best_months'] as number[]) ?? []).map(Number),
+  }
+}
+
+export function evaluateChoice(cand: Candidate, req: TravelRequest, ch: Choice): TrueCost {
+  /** 门到门全成本核算(与 Python evaluate_choice 完全一致)。 */
+  const access = req.homeHubAccess[cand.hub]
+  const wake = ch.outService.depMin - cand.bufferOutMin - access.toHubMin
+  const arriveStay = ch.outService.arrMin + ch.outTransfer.minutes
+  const d2dOut = arriveStay - wake
+
+  let energy = 100
+  if (wake < 5 * 60) energy -= WAKE_PENALTY_BEFORE_5
+  else if (wake < 6 * 60) energy -= WAKE_PENALTY_BEFORE_6
+  else if (wake < hhmmToMin('06:30')) energy -= WAKE_PENALTY_BEFORE_630
+  energy -= 2 * TRANSFER_PENALTY
+  if (arriveStay > 21 * 60) energy -= LATE_ARRIVAL_PENALTY
+  if (d2dOut > 6 * 60) energy -= LONG_D2D_PENALTY
+  energy = Math.max(0, energy)
+
+  const day1Raw = Math.max(0, DAY_END_MIN - arriveStay) / 60
+  const day1 = day1Raw * (0.5 + energy / 200)
+  const leaveStayRet = ch.retService.depMin - cand.bufferRetMin - ch.retTransfer.minutes
+  const day2 = Math.max(0, leaveStayRet - DAY2_START_MIN) / 60 * DAY2_QUALITY
+  const midDays = Math.max(0, ch.days - 2)
+  const usable = day1 + day2 + midDays * 8.0 * DAY2_QUALITY
+
+  const money =
+    ch.outService.priceCny + ch.retService.priceCny
+    + ch.outTransfer.priceCny + ch.retTransfer.priceCny
+    + cand.stayCnyPerNight * (ch.days - 1)
+    + cand.localDailyCny * ch.days
+
+  return {
+    moneyCny: money,
+    wakeMin: wake,
+    arriveStayMin: arriveStay,
+    doorToDoorOutMin: d2dOut,
+    energyArrivalPct: energy,
+    usableHours: usable,
+    usableDay1Hours: day1,
+    usableDay2Hours: day2,
+    departHomeRetMin: leaveStayRet,
+    arriveHomeRetMin: ch.retService.arrMin + access.toHubMin,
+  }
+}
+
+export function trueCostToDict(t: TrueCost): Record<string, unknown> {
+  return {
+    money_cny: t.moneyCny,
+    wake: minToHhmm(t.wakeMin),
+    arrive_stay: minToHhmm(t.arriveStayMin),
+    door_to_door_out: `${Math.floor(t.doorToDoorOutMin / 60)}h${String(t.doorToDoorOutMin % 60).padStart(2, '0')}m`,
+    energy_arrival_pct: t.energyArrivalPct,
+    usable_hours: Math.round(t.usableHours * 10) / 10,
+    usable_day1_hours: Math.round(t.usableDay1Hours * 10) / 10,
+    usable_day2_hours: Math.round(t.usableDay2Hours * 10) / 10,
+    leave_stay_return: minToHhmm(t.departHomeRetMin),
+    arrive_home_return: minToHhmm(Math.min(1440, t.arriveHomeRetMin)),
+  }
+}