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

package/ts/src/loop.ts

@@ -8,6 +8,7 @@
 
 import type { InterviewQuestion, TripState, TravelerProfile, Turn, CalendarState, SolveResult } from './contracts.ts'
 import type { JourneySpecTS } from './unified.ts'
+import { buildTimeAnchor, isRealIsoDate, planningWindowBounds, parsePlanningWindow, type PlanningWindow, type TimeAnchor } from './time-anchor.ts'
 import type { TravelSlotExtraction } from './travel-slots.ts'
 import { anythingSearch } from '../capabilities/anything.ts'
 
@@ -95,6 +96,98 @@ export function validateSpec(spec: JourneySpecTS): string | null {
   return null
 }
 
+export interface PlanningWindowRejection {
+  segmentId: string
+  optionId: string
+  date: string
+}
+
+export interface PlanningWindowCheck {
+  spec: JourneySpecTS
+  rejected: PlanningWindowRejection[]
+  error?: string
+}
+
+export interface PlanningWindowOptions {
+  /** Registered feasibility tool opts into the dated-candidate default future floor. */
+  defaultDatedFuture?: boolean
+}
+
+function isoDateInBounds(date: string, bounds: { start: string; end: string }): boolean {
+  const m = date.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+  if (!m || !isRealIsoDate(Number(m[1]), Number(m[2]), Number(m[3]))) return false
+  return date >= bounds.start && date <= bounds.end
+}
+
+function hasDatedCandidates(spec: JourneySpecTS): boolean {
+  return spec.segments.some(segment => segment.date !== undefined || segment.options.some(option => option.date !== undefined))
+}
+
+/**
+ * Enforce a named-year future window at the planner boundary. Historical
+ * lookup/backtesting remains an explicit bypass; an expired named year fails
+ * instead of being silently rolled into a different year.
+ */
+export function applyPlanningWindow(
+  spec: JourneySpecTS,
+  window: PlanningWindow | null,
+  anchor: TimeAnchor,
+  options: PlanningWindowOptions = {},
+): PlanningWindowCheck {
+  // Dated recommendations are future-oriented even without optional named-year context.
+  // Fully dateless legacy calculations remain untouched; historical bypass is explicit.
+  if (window?.intent === 'historical') return { spec, rejected: [] }
+  const implicitFutureFloor = !window && options.defaultDatedFuture === true && hasDatedCandidates(spec)
+  if (!window && !implicitFutureFloor) return { spec, rejected: [] }
+
+  const currentYear = Number(anchor.today.slice(0, 4))
+  if (window && window.requestedYear < currentYear) {
+    return {
+      spec,
+      rejected: [],
+      error: `${window.requestedYear} 年已结束(当前规划参考日 ${anchor.today}),不会自动改用其他年份;如需历史查询请明确说明“历史/回测”。`,
+    }
+  }
+
+  const bounds = window
+    ? planningWindowBounds(window, anchor)
+    : { start: anchor.today, end: '9999-12-31' }
+  if (!bounds) return { spec, rejected: [], error: `无法建立 ${window!.requestedYear} 年的未来规划窗口。` }
+
+  const rejected: PlanningWindowRejection[] = []
+  const guardedSegments = spec.segments.map(segment => ({
+    ...segment,
+    options: segment.options.filter(option => {
+      const date = option.date ?? segment.date
+      if (date && isoDateInBounds(date, bounds)) return true
+      rejected.push({ segmentId: segment.id, optionId: option.id, date: date ?? '未提供明确日期' })
+      return false
+    }),
+  }))
+
+  if (guardedSegments.some(segment => segment.options.length === 0)) {
+    return {
+      spec: { ...spec, segments: guardedSegments },
+      rejected,
+      error: implicitFutureFloor
+        ? `带日期的未来推荐必须不早于当前规划参考日 ${bounds.start};没有带明确日期且在未来窗口内的可接受方案。`
+        : `${window!.requestedYear} 年未来规划窗口为 ${bounds.start} 至 ${bounds.end};没有带明确日期且落在窗口内的可接受方案。`,
+    }
+  }
+  return { spec: { ...spec, segments: guardedSegments }, rejected }
+}
+
+function latestPlanningWindow(history: Turn[], userMsg: string, anchor: TimeAnchor): PlanningWindow | null {
+  const turns = [...history, { role: 'user' as const, text: userMsg }]
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const turn = turns[i]
+    if (turn?.role !== 'user') continue
+    const parsed = parsePlanningWindow(turn.text, anchor)
+    if (parsed) return parsed
+  }
+  return null
+}
+
 /** 求解端口:S3 起由 unified 求解器实现;循环只认此签名(确定性责任)。 */
 export type SolvePort = (spec: JourneySpecTS) => Promise<SolveResult>
 
@@ -206,15 +299,15 @@ export function renderSolve(state: TripState): string {
       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})`)
   }
+  for (const e of s.work_window_exclusions ?? []) {
+    lines.push(`- 已排除 ${e.option}(工作窗口):${e.reason}`)
+  }
   if (state.gates.length) {
     lines.push('', '**待你决定(选择题)**')
     for (const g of state.gates) {
@@ -231,7 +324,9 @@ export async function runTurn(
   llm: LlmPort,
   history: Turn[] = [],
   solve: SolvePort | null = null,
+  now: Date = new Date(),
 ): Promise<{ reply: string; state: TripState }> {
+  const anchor = buildTimeAnchor(now)
   const facts = await llm.extractFacts([...history, { role: 'user', text: userMsg }], state)
 
   const conflicts: string[] = []
@@ -287,7 +382,22 @@ export async function runTurn(
 
   // 约束齐备(无阻塞问题)→ 翻译 spec → **校验闸 + 日期一致性闸** → 求解 → 渲染
   if (blocking.length === 0 && solve) {
-    const spec = await llm.extractSpec([...history, { role: 'user', text: userMsg }], state)
+    const extractedSpec = await llm.extractSpec([...history, { role: 'user', text: userMsg }], state)
+    const planning = latestPlanningWindow(history, userMsg, anchor)
+    const planningCheck = extractedSpec ? applyPlanningWindow(extractedSpec, planning, anchor) : null
+    if (planningCheck?.error) {
+      state.spec = undefined
+      state.solve = undefined
+      parts.push(`⚠️ ${planningCheck.error}`)
+      return { reply: parts.join('\n\n'), state }
+    }
+    if (planningCheck?.rejected.length) {
+      const rejected = planningCheck.rejected
+        .map(r => `${r.segmentId}/${r.optionId}(${r.date})`)
+        .join('、')
+      parts.push(`已排除规划窗口外的候选:${rejected}`)
+    }
+    const spec = planningCheck?.spec ?? extractedSpec
     // 场景路由:erhai 候选标记 → 候选求解(洱海金标准的引擎判定)——纯 TS unify 路径
     if (spec && (spec as unknown as { note?: string }).note === 'erhai-candidates') {
       const { readFile } = await import('node:fs/promises')
@@ -311,11 +421,10 @@ export async function runTurn(
         // D-10 切片 C:spec↔槽位日期一致性闸(ADR-10 翻译≠造数的执行点)。
         // LLM 翻译的 spec 日期与代码层换算的槽位日期分歧时不求解、不猜,追问确认——
         // 日期是求解关键输入,错日期 = 错判决。槽位缺失/unresolved 不参与(不造假阳性)。
-        const ext = await llm.extractSlots([...history, { role: 'user', text: userMsg }])
+        const ext = await llm.extractSlots([...history, { role: 'user', text: userMsg }], now)
         if (ext) {
           const { resolveSlots, specDateMismatches } = await import('./slot-spec.ts')
-          const { buildTimeAnchor } = await import('./time-anchor.ts')
-          const mismatches = specDateMismatches(spec, resolveSlots(ext, buildTimeAnchor()))
+          const mismatches = specDateMismatches(spec, resolveSlots(ext, anchor))
           if (mismatches.length > 0) {
             const lines = mismatches.map(m => `- ${m.specAt}:翻译说 ${m.specDate},你的原话换算是 ${m.slotDate}(${m.field})`)
             parts.push(`⚠️ 日期分歧,确认后我再算(以你为准):\n${lines.join('\n')}`)

package/ts/src/memory-capture.ts

@@ -9,31 +9,143 @@
  *     ① 追加不删史(evidence 永不移除,P0 反幻觉:历史依据不可篡改)
  *     ② 幂等(同 evidence 不重复入池)
  *     ③ 结构守卫(weights 存在性校验、空补丁拒绝、权重归一)
+ *
+ * 额外承载(issue #338):用户显式声明的常驻城市/默认出发地——typed
+ * homeCity 字段 + 纯函数 resolveDefaultOrigin(explicit origin, profile)。
+ *   - 当前轮显式出发地永远赢(explicit origin > home city > missing)
+ *   - homeCity 变更必须伴新 evidence(P0 与 weights/hard 同向);单条 evidence
+ *     可作为省略 binding 的兼容形态,多条 evidence 必须显式绑定
+ *   - 该契约不触碰算术/求解——只读字段,不进 feasibility/evaluate 路径
+ *
+ * 持久化语义(issue #338):home-city 是 typed self-contained preference
+ * 记录 `{ value, evidence, updated_at }`,与全局 evidence 列表解耦——
+ * 一次不相关的动机补丁不会改写它的「证据指针」「更新时间」「当前值」。
+ * `updated_at` 由调用方在事件边界注入(账本事件行的 ts),mergeProfile
+ * 自身不在 fold 路径里再读时钟——保证 rebuildProjections() 与直读投影
+ * 永不分叉。
  */
 
+export interface HomeCityPreference {
+  /** string=当前默认城市,null=已显式清除(审计一行留痕) */
+  value: string | null
+  /** 锁定到本次 home-city 操作的用户原话指针(append-only evidence 池里的那条) */
+  evidence: string
+  /** 账本事件行的 ts(非折叠期再读时钟) */
+  updated_at: string
+}
+
 export interface ProfilePatch {
   weights?: Record<string, number>
   /** 新增依据(用户原话或工具证据);只增不改不删 */
   evidence?: string[]
   hard?: Record<string, unknown>
+  /**
+   * 持久化用户常驻城市/默认出发地(issue #338)。
+   *   - string = 设置默认城市(用户原话指明常驻)
+   *   - null   = 显式清除(审计一行留痕,用于遗忘/迁居)
+   *   - undefined = 字段未传,保持当前值不动
+   * 改值须伴至少一条新 evidence(同 weights/hard 的 P0 守卫);恰好一条非空
+   * evidence 时可省略 homeCityEvidence,多条 evidence 必须显式绑定。
+   * 进入合并前会 trim;trim 后空白 → 视为「未传」,不触发变更、不落事件。
+   */
+  homeCity?: string | null
+  /**
+   * homeCity 在本次 profile.evidence 中的 exact 用户原话绑定。
+   * 显式传入时必须非空、逐字出现在 evidence 且相对当前画像为新值;
+   * 未传时仅允许 evidence 恰好一条且非空,由该条提供 unambiguous binding;
+   * 唯一例外是同 value/clear state + 同 typed evidence 的重复调用(幂等)。
+   */
+  homeCityEvidence?: string
 }
 
 export interface MergedProfile {
   weights: Record<string, number>
   evidence: string[]
   hard: Record<string, unknown>
+  /** 当前持久默认城市。undefined 从未保存;null 显式清除;string 当前默认。 */
+  homeCity?: string | null
+  /**
+   * home-city 自含记录(issue #338):value + 锁定证据 + 更新时间三件套,
+   * 与全局 evidence 列表解耦。缺少或不满足完整 typed contract 的画像按
+   * missing 处理;raw homeCity 不会成为默认值或证据来源。
+   */
+  homeCityPreference?: HomeCityPreference
+}
+
+const ISO_LIKE_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,3})?(Z|[+-]\d{2}:\d{2})$/
+
+function isNonBlankString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function isValidIsoLikeTimestamp(value: unknown): value is string {
+  if (typeof value !== 'string') return false
+  const match = ISO_LIKE_TIMESTAMP.exec(value)
+  if (!match) return false
+  const year = Number(match[1])
+  const month = Number(match[2])
+  const day = Number(match[3])
+  const hour = Number(match[4])
+  const minute = Number(match[5])
+  const second = Number(match[6])
+  const zone = match[7]!
+  const daysInMonth = month === 2
+    ? (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28)
+    : [31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1]
+  if (!daysInMonth || day < 1 || day > daysInMonth) return false
+  // ISO permits 24:00:00 as the end-of-day spelling; no other 24:xx value.
+  if (hour > 23 && !(hour === 24 && minute === 0 && second === 0)) return false
+  if (minute > 59 || second > 59) return false
+  if (zone !== 'Z' && (Number(zone.slice(1, 3)) > 23 || Number(zone.slice(4, 6)) > 59)) return false
+  return Number.isFinite(Date.parse(value))
 }
 
-/** 与现有画像合并;无可并入内容返回 null(调用方跳过落盘)。纯函数。 */
+/**
+ * Typed home-city preference 的唯一有效性判定。
+ * 不读取、不修写 raw profile;raw homeCity 若存在只作镜像一致性校验。
+ */
+export function isValidHomeCityPreference(profile: {
+  homeCity?: unknown
+  evidence?: unknown
+  homeCityPreference?: unknown
+} | null): boolean {
+  const preference = profile?.homeCityPreference
+  if (!preference || typeof preference !== 'object' || Array.isArray(preference)) return false
+  const candidate = preference as Partial<HomeCityPreference>
+  if (!(candidate.value === null || isNonBlankString(candidate.value))) return false
+  if (!isNonBlankString(candidate.evidence) || !isValidIsoLikeTimestamp(candidate.updated_at)) return false
+  if (!profile || !Array.isArray(profile.evidence) || !profile.evidence.some(entry => entry === candidate.evidence)) return false
+  if (profile && Object.prototype.hasOwnProperty.call(profile, 'homeCity') && profile.homeCity !== candidate.value) return false
+  return true
+}
+
+/**
+ * 合并守门。纯函数;不读时钟——`now` 由调用方从事件边界(appendMotivationPatch
+ * 写时 ISO 或 foldEvent 重放时 row.ts)注入,保证写路径与重建路径时间戳一致。
+ *
+ * 触发 homeCity 操作的同时,会原地维护 typed homeCityPreference:
+ *   - valid new binding → 新 `{value, evidence: <homeCityEvidence exact string>, updated_at: now}`
+ *   - unchanged → 沿用 base 的 homeCityPreference(若有);缺失 typed 字段保持缺失
+ *   - missing/mismatched/stale binding → 返回 null,由账本跳过整次事件
+ */
 export function mergeProfile(
-  current: { weights?: Record<string, number>; evidence?: string[]; hard?: Record<string, unknown> } | null,
+  current: {
+    weights?: Record<string, number>
+    evidence?: string[]
+    hard?: Record<string, unknown>
+    homeCity?: string | null
+    homeCityPreference?: HomeCityPreference
+  } | null,
   patch: ProfilePatch | null,
+  now: string,
 ): MergedProfile | null {
   if (!patch) return null
   const base = {
     weights: (current?.weights ?? {}) as Record<string, number>,
     evidence: (current?.evidence ?? []) as string[],
     hard: (current?.hard ?? {}) as Record<string, unknown>,
+    homeCity: (current?.homeCity === undefined ? undefined : current.homeCity) as string | null | undefined,
+    homeCityPreference: current?.homeCityPreference as HomeCityPreference | undefined,
   } // 首次保存:无档案即空档案
   const newEvidence = (patch.evidence ?? []).filter(Boolean).filter(e => !base.evidence.includes(e))
   const patchWeights = patch.weights
@@ -41,7 +153,46 @@ export function mergeProfile(
     JSON.stringify(patchWeights) !== JSON.stringify(base.weights)
   const hardChanged = !!patch.hard && Object.keys(patch.hard).length > 0 &&
     JSON.stringify(patch.hard) !== JSON.stringify(base.hard)
-  if (newEvidence.length === 0 && !weightsChanged && !hardChanged) return null
+  // homeCity 变更判定:
+  //   patch.homeCity === undefined → 字段未传,不视为变更
+  //   string 先 trim;trim 后空白 → 视作「未传」(避免把空白值当清除语义或无意义值写入)
+  //   trim 后与 base.homeCity 仍不等 → 视为变更(包括 string↔null、null↔undefined 等差异)
+  let patchedHomeCityInput: string | null | undefined = patch.homeCity
+  if (typeof patchedHomeCityInput === 'string') {
+    const trimmed = patchedHomeCityInput.trim()
+    patchedHomeCityInput = trimmed.length === 0 ? undefined : trimmed
+  }
+  const homeCityTouched = patchedHomeCityInput !== undefined
+  const homeCityChanged = homeCityTouched && patchedHomeCityInput !== base.homeCity
+
+  if (!homeCityTouched && patch.homeCityEvidence !== undefined) return null
+
+  // homeCity 的语义绑定必须在 profile patch 边界明确给出,不从自然语言或
+  // evidence 数组位置推断。唯一兼容例外:本次只有一条非空 evidence 时,
+  // 该条本身就是 unambiguous binding;多条 evidence 仍必须显式命名。
+  let homeCityEvidence: string | undefined
+  let homeCityEvidenceIsNew = false
+  if (homeCityTouched) {
+    const evidenceEntries = patch.evidence ?? []
+    const candidate = patch.homeCityEvidence !== undefined
+      ? patch.homeCityEvidence
+      : evidenceEntries.length === 1 && isNonBlankString(evidenceEntries[0])
+        ? evidenceEntries[0]
+        : undefined
+    const appearsInCall = isNonBlankString(candidate) && evidenceEntries.some(e => e === candidate)
+    homeCityEvidenceIsNew = appearsInCall && !base.evidence.includes(candidate)
+    const exactDuplicate = appearsInCall && !homeCityEvidenceIsNew && !homeCityChanged
+      && base.homeCityPreference?.value === patchedHomeCityInput
+      && base.homeCityPreference?.evidence === candidate
+    if (!appearsInCall || (!homeCityEvidenceIsNew && !exactDuplicate)) return null
+    homeCityEvidence = candidate
+  }
+
+  // A same-city/clear operation with a new bound quote is a real preference
+  // update even though the value itself did not change. The exact duplicate
+  // above remains a no-op.
+  const homeCityPreferenceChanged = homeCityTouched && homeCityEvidenceIsNew
+  if (newEvidence.length === 0 && !weightsChanged && !hardChanged && !homeCityChanged && !homeCityPreferenceChanged) return null
 
   // 权重变更必须伴至少一条新 evidence(P0:改画像要有依据),否则拒该部分
   let weights = { ...base.weights }
@@ -51,9 +202,82 @@ export function mergeProfile(
     if (sum > 0) for (const k of Object.keys(weights)) weights[k] = Math.round((weights[k]! / sum) * 100) / 100
   }
 
+  // homeCity 操作只接受上面验证过的 exact homeCityEvidence 绑定;无关 evidence
+  // 可以继续追加到全局池,但绝不会成为 homeCityPreference 的语义指针。
+  let homeCity: string | null | undefined = base.homeCity
+  let homeCityPreference: HomeCityPreference | undefined = base.homeCityPreference
+  if (homeCityPreferenceChanged) {
+    homeCity = patchedHomeCityInput ?? null
+    if (homeCityEvidence !== undefined) {
+      homeCityPreference = { value: homeCity, evidence: homeCityEvidence, updated_at: now }
+    }
+  }
+
   return {
     weights,
     evidence: [...base.evidence, ...newEvidence],
     hard: hardChanged ? { ...base.hard, ...(patch.hard ?? {}) } : { ...base.hard },
+    homeCity,
+    homeCityPreference,
+  }
+}
+
+/**
+ * 默认出发地解析契约(issue #338)。
+ *
+ * 纯函数,不读文件、不查 IP/浏览器位置/语言/时区/历史行程;不构造新 evaluate/solve 路径。
+ * 调用方负责传入当轮上下文(currentTripOrigin)与持久画像(profile)。
+ *
+ * 三态判决:
+ *   - explicit    当轮显式出发地(用户当轮输入);永远赢,不被持久默认覆盖
+ *   - home_default 持久化 homeCity;仅在当轮未指定时填补缺省(用于软排序/兜底)
+ *   - missing     二者皆空或显式已清除;调用方须向用户澄清而非自行猜测
+ *
+ * 该契约的硬约束:
+ *   - 不删除候选、不改变可行性判定、不进 evaluate/solve 路径
+ *   - 「只进软排序/补缺」语义由调用方在排序/回退层使用本结果
+ *
+ * 证据来源:只接受 self-contained typed preference(issue #338)的完整合同。
+ * 缺字段、镜像不一致或字段 malformed 的画像一律 missing,不从 raw homeCity
+ * 或全局 evidence 推断默认值/原话。
+ */
+export interface DefaultOriginResolution {
+  /** 解析后的出发地;null = 调用方应澄清 */
+  origin: string | null
+  /** 取值来源 */
+  source: 'explicit' | 'home_default' | 'missing'
+  /** 当前持久 homeCity(原值,便于 UI/日志/审计展示) */
+  homeCity: string | null | undefined
+  /** 锁定到本次 home-city 操作的用户原话指针;仅 valid home_default 填 */
+  homeCityEvidence?: string[]
+  /** 是否来自完整 typed preference 路径(便于 audit/UI 区分) */
+  homeCityPreferenceSource: 'typed' | 'none'
+}
+
+export function resolveDefaultOrigin(
+  currentTripOrigin: string | null | undefined,
+  profile: {
+    homeCity?: string | null
+    evidence?: string[]
+    homeCityPreference?: HomeCityPreference
+  } | null,
+): DefaultOriginResolution {
+  const trimmed = typeof currentTripOrigin === 'string' ? currentTripOrigin.trim() : ''
+  const validTypedPreference = isValidHomeCityPreference(profile)
+  const preference = validTypedPreference ? profile?.homeCityPreference as HomeCityPreference : undefined
+  const typedValue = preference?.value
+  const homeCity = validTypedPreference ? typedValue : undefined
+  if (trimmed) {
+    return { origin: trimmed, source: 'explicit', homeCity, homeCityPreferenceSource: 'none' }
+  }
+  if (validTypedPreference && typeof typedValue === 'string') {
+    return {
+      origin: typedValue.trim(),
+      source: 'home_default',
+      homeCity,
+      homeCityEvidence: [preference!.evidence],
+      homeCityPreferenceSource: 'typed',
+    }
   }
+  return { origin: null, source: 'missing', homeCity, homeCityPreferenceSource: 'none' }
 }

package/ts/src/mock-llm.ts

@@ -9,6 +9,7 @@ import type { InterviewQuestion, TravelerProfile, TripState, Turn, CalendarState
 import type { JourneySpecTS } from './unified.ts'
 import type { TravelSlotExtraction } from './travel-slots.ts'
 import { parseFlightPackToSpec } from './unified.ts'
+import { mergeProfileWorkWindow } from './flight-pack-adapter.ts'
 
 interface ScriptStep {
   /** 命中条件:用户消息包含此关键词(第一条匹配生效) */
@@ -79,14 +80,9 @@ export function createMockLlm(flightPackPath?: string, slotScript: SlotScriptSte
       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
+      const merged = mergeProfileWorkWindow(spec, state.profile.workWindow)
+      merged.budgetCny = 9000
+      return merged
     },
     async extractSlots(history: Turn[]): Promise<TravelSlotExtraction | null> {
       const last = history[history.length - 1]?.text ?? ''

package/ts/src/model.ts

@@ -19,6 +19,16 @@ export interface TransferMode {
   mode: string
   minutes: number
   priceCny: number
+  /**
+   * Per-direction overrides supplied by the ground-transfer capability when a
+   * driving route fact successfully resolves for outbound (A→B) and/or return
+   * (B→A). `minutesOut` feeds the outbound arrival stay minute;
+   * `minutesRet` feeds the return departure-from-stay minute. When absent
+   * the solver falls back to the symmetric `minutes` field, preserving
+   * byte-for-byte behavior for static and symmetric inputs.
+   */
+  minutesOut?: number
+  minutesRet?: number
 }
 
 export interface Service {
@@ -26,6 +36,14 @@ export interface Service {
   depMin: number
   arrMin: number
   priceCny: number
+  /**
+   * Issue #343 v2 路径填充(可选):service 出发/到达对应的真实 UTC instant(epoch ms)。
+   * 同一 service 在 arrMin - depMin ≤ 真实飞行时长 跨日 / DST 切换场景下需要这两个字段
+   * 才能算出正确的 (arrUtcMs - depUtcMs) / 60000。v1 数值路径不填,由 evaluateChoice/Segment 走
+   * 旧 `(arrMin - depMin) - tzOffsetMin` 公式,字节不变。
+   */
+  depUtcMs?: number
+  arrUtcMs?: number
 }
 
 export interface HubAccess {
@@ -46,6 +64,8 @@ export interface MotivationProfile {
 export interface Candidate {
   id: string
   name: string
+  /** 可选的明确出行日;未提供时保持旧版无日期可行性计算语义 */
+  date?: string
   hub: string
   bufferOutMin: number
   bufferRetMin: number
@@ -147,6 +167,7 @@ export function parseCandidate(d: Record<string, unknown>): Candidate {
   return {
     id: String(d['id']),
     name: String(d['name']),
+    date: typeof d['date'] === 'string' ? d['date'] : undefined,
     hub: String(d['hub']),
     bufferOutMin: Number(d['buffer_out_min'] ?? 60),
     bufferRetMin: Number(d['buffer_ret_min'] ?? 60),
@@ -161,11 +182,76 @@ export function parseCandidate(d: Record<string, unknown>): Candidate {
   }
 }
 
+/** Issue #343 d2d canonical arithmetic。 */
+export class NonpositiveDurationError extends Error {
+  /** 'arr_not_after_dep' | 'legacy_negative_offset' */
+  readonly kind: 'arr_not_after_dep' | 'legacy_negative_offset'
+  readonly code = 'nonpositive_duration'
+  constructor(kind: 'arr_not_after_dep' | 'legacy_negative_offset', message: string) {
+    super(message)
+    this.kind = kind
+    this.name = 'NonpositiveDurationError'
+  }
+}
+
+/**
+ * doorToDoorFromMove 所需的最小 move 字段。本模型层不耦合 unified.ts 的 MoveSpecTS(避免循环)。
+ * unified.ts evaluateOptionMove 必须用这个 helper,而不是再写一份 (arrUtcMs - depUtcMs)/60000。
+ */
+export interface D2DMoveView {
+  bufferMin: number
+  originTransferMin: number
+  destTransferMin: number
+  /** 仅 v1 路径用;v2 路径无需。 */
+  tzOffsetMin?: number
+}
+
+export interface DoorToDoorParts {
+  /** 真实飞行时长(分);v2 = (arrUtcMs - depUtcMs)/60000,v1 = (arrMin - depMin) - tzOffsetMin */
+  trueFlightMin: number
+  /** 门到门(分) = buffer + originTransfer + trueFlight + destTransfer */
+  doorToDoorMin: number
+}
+
+/**
+ * 单段门到门时长(分)。v2 路径用真实 UTC instant(跨日 / 反向日界线 / DST 切换正确),
+ * 且强制 `arrUtcMs > depUtcMs` — parse 边界也会再做一次防御性 throw。
+ * v1 路径用墙上分钟差 - tzOffsetMin(原数值口径,字节不变,即使结果为负也照旧返回)。
+ *
+ * v2:arrUtcMs 必须严格大于 depUtcMs;否则抛 NonpositiveDurationError(arr_not_after_dep)。
+ * v1:沿用 legacy 公式,字节不变;不抛错。
+ *
+ * 调用方(unified.ts evaluateOptionMove)只负责拿到 doorToDoorMin 并包装 LegReport。
+ */
+export function doorToDoorFromMove(svc: Service, mv: D2DMoveView): DoorToDoorParts {
+  if (typeof svc.depUtcMs === 'number' && typeof svc.arrUtcMs === 'number') {
+    if (svc.arrUtcMs <= svc.depUtcMs) {
+      throw new NonpositiveDurationError(
+        'arr_not_after_dep',
+        `service ${svc.id}: arrUtcMs (${svc.arrUtcMs}) must be strictly greater than depUtcMs (${svc.depUtcMs})`,
+      )
+    }
+    const trueFlightMin = (svc.arrUtcMs - svc.depUtcMs) / 60_000
+    const doorToDoorMin = mv.bufferMin + mv.originTransferMin + trueFlightMin + mv.destTransferMin
+    return { trueFlightMin, doorToDoorMin }
+  }
+  // v1 legacy 字节不变:不校验正负,沿用原公式。
+  const trueFlightMin = (svc.arrMin - svc.depMin) - (mv.tzOffsetMin ?? 0)
+  const doorToDoorMin = mv.bufferMin + mv.originTransferMin + trueFlightMin + mv.destTransferMin
+  return { trueFlightMin, doorToDoorMin }
+}
+
 export function evaluateChoice(cand: Candidate, req: TravelRequest, ch: Choice): TrueCost {
   /** 门到门全成本核算(与 Python evaluate_choice 完全一致)。 */
   const access = req.homeHubAccess[cand.hub]
+  const outTransferMin = typeof ch.outTransfer.minutesOut === 'number'
+    ? ch.outTransfer.minutesOut
+    : ch.outTransfer.minutes
+  const retTransferMin = typeof ch.retTransfer.minutesRet === 'number'
+    ? ch.retTransfer.minutesRet
+    : ch.retTransfer.minutes
   const wake = ch.outService.depMin - cand.bufferOutMin - access.toHubMin
-  const arriveStay = ch.outService.arrMin + ch.outTransfer.minutes
+  const arriveStay = ch.outService.arrMin + outTransferMin
   const d2dOut = arriveStay - wake
 
   let energy = 100
@@ -179,7 +265,7 @@ export function evaluateChoice(cand: Candidate, req: TravelRequest, ch: Choice):
 
   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 leaveStayRet = ch.retService.depMin - cand.bufferRetMin - retTransferMin
   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