@danceiny/gotry 0.0.1-rc.9 → 0.2.0-rc.28

package/ts/src/travel-timeline.ts

@@ -0,0 +1,83 @@
+/**
+ * 旅行时间线(memory-design M4 层,P1):「去过哪、何时、和谁」的 append-only 事实层。
+ *
+ * 立场(memory-design §1):确定性事实归代码——日期解析复用 slot-spec(锚点卡词表+绝对),
+ * 词表外 unresolved 不猜;每条事件必须带 evidence(用户原话或 wish 确认),溯源 P0。
+ * 消费:出发地三级解析(未来行程→时间线→问用户)/「去过不再推」排序通道/
+ * 回流率分子(verified_outcome ⟺ timeline 有对应行程)。
+ * 多用户前向兼容:append-only + 稳定 trip_id,账本化只换存储面(RFC §6.5)。
+ */
+
+import { parseAbsoluteDate, ymd, type TimeAnchor } from './time-anchor.ts'
+import { resolveSlotDate } from './slot-spec.ts'
+
+export type TimelineSource = 'user-verbatim' | 'wish-confirmed'
+
+export interface TimelineEvent {
+  schema: 'travel_timeline.v1'
+  /** 稳定主键:语义派生(目的地|start|source),重放 no-op */
+  trip_id: string
+  destination: string
+  /** YYYY-MM-DD(入库前必须已解析为绝对日期) */
+  start: string
+  end?: string
+  companions?: string[]
+  source: TimelineSource
+  /** 用户原话或 wish confirm-outcome 指针 */
+  evidence: string
+  ts: string
+}
+
+/** 相对/模糊表达 → 绝对日期(守门:词表外返回 null,调用方必须拒收而非猜) */
+export function resolveTimelineDate(expr: string, anchor: TimeAnchor): string | null {
+  return resolveSlotDate(expr, anchor).date
+}
+
+/** 语义主键:同目的地+同 start+同 source = 同一行程(重放 no-op) */
+export function makeTripId(ev: Omit<TimelineEvent, 'schema' | 'trip_id' | 'ts'>): string {
+  return `${ev.destination}|${ev.start}|${ev.source}`.replace(/\s+/g, '_')
+}
+
+/**
+ * 追加守门(纯函数,不改入参):
+ *  - destination/evidence 必填,start 必须已是绝对日期(YYYY-MM-DD),否则拒收(null);
+ *  - end < start 拒收;
+ *  - 同 trip_id 已存在 → no-op(返回 appended:false,幂等);
+ *  - 同目的地日期区间重叠(不同 trip_id)→ 拒收(冲突即停,由人裁决)。
+ */
+export function appendTrip(
+  events: TimelineEvent[],
+  ev: Omit<TimelineEvent, 'schema' | 'trip_id' | 'ts'>,
+): { events: TimelineEvent[]; appended: boolean; tripId?: string; reason?: string } {
+  if (!ev.destination?.trim()) return { events, appended: false, reason: 'destination 必填' }
+  if (!ev.evidence?.trim()) return { events, appended: false, reason: 'evidence 必填(用户原话或 wish 确认指针)' }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(ev.start)) return { events, appended: false, reason: 'start 必须为 YYYY-MM-DD(词表外日期由上游解析,不猜)' }
+  if (ev.end && ev.end < ev.start) return { events, appended: false, reason: 'end 早于 start' }
+  const tripId = makeTripId(ev)
+  if (events.some(e => e.trip_id === tripId)) return { events, appended: false, tripId }
+  const overlap = events.find(e => e.destination === ev.destination && !(e.end && e.end < ev.start) && !(ev.end && ev.end < e.start))
+  if (overlap) return { events, appended: false, tripId: overlap.trip_id, reason: `与已有行程 ${overlap.trip_id} 日期重叠,冲突即停` }
+  const full: TimelineEvent = { schema: 'travel_timeline.v1', trip_id: tripId, ts: new Date().toISOString(), ...ev }
+  return { events: [...events, full], appended: true, tripId }
+}
+
+/** 只读投影:按 start 倒序的行程摘要(「去过」行/brief 注入用) */
+export function projectTimeline(events: TimelineEvent[]): Array<{ tripId: string; destination: string; start: string; end?: string; companions?: string[] }> {
+  return [...events]
+    .sort((a, b) => (a.start < b.start ? 1 : -1))
+    .map(e => ({ tripId: e.trip_id, destination: e.destination, start: e.start, end: e.end, companions: e.companions }))
+}
+
+/**
+ * 交叉一致(回流率分子的质变):verified_outcome 的 wish 应有对应时间线行程。
+ * 返回缺口清单(verified 但无 timeline)——巡检口径,不自动补写(补写需要用户确认日期)。
+ */
+export function timelineGapsForVerified(
+  timeline: TimelineEvent[],
+  verifiedWishes: Array<{ wishId: string; destination?: string }>,
+): Array<{ wishId: string }> {
+  const dests = new Set(timeline.map(t => t.destination))
+  return verifiedWishes.filter(w => w.destination && !dests.has(w.destination)).map(w => ({ wishId: w.wishId }))
+}
+
+export { ymd }

package/ts/src/turn-deadline.ts

@@ -0,0 +1,366 @@
+/**
+ * Per-agent, per-turn wall-clock boundary driven by routing (ADR-24 v2).
+ *
+ * 职责只有一件:保证每一轮终结在三态之一——当面答完(converge)、转后台
+ * 并给出回访承诺(handoff)、或明确暂停。绝不允许第四态:流死掉、什么
+ * 都没交付(2026-09-02 轨迹的失败形态)。
+ *
+ * - 阈值不再固定:每次 user/message 由 `turn-policy.ts` 的确定性分类器
+ *   解析 TurnPolicy(softMs/hardMs/exit);benchmark opt-in 用 fixedPolicy
+ *   钉死以保证可复现。
+ * - 硬阈拒绝时**同步**抑制工具 schema(防同 step 回环),并按 exit 语义
+ *   返回两种结构化结果:converge=用已有证据作答;handoff=落
+ *   `gotry_turn_handoff.v1` 工单并指令模型告知用户 ETA 与回访方式。
+ * - handoff 工单是**新的独立格式**,落在 `<stateRoot>/gotry-state/
+ *   turn-handoffs/`,不与 `async/` 的 loop 求解工单混用——async-collect
+ *   对无 spec 的 state 会立即结算 failed(假失败),收集器是未来的
+ *   agent tick(loopx),不是 async-collect。
+ */
+
+import { randomUUID } from 'node:crypto'
+import { mkdir, readdir, readFile, rename, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import type { Context } from '@deepseek-ai/cordis'
+import type { Agent } from '@deepseek-ai/dsh-agent'
+// 类型面显式依赖:session/event、session/disposed 的事件表声明在 dsh-session 的
+// cordis Events augmentation 里——不显式导入时,该声明只在 peer 恰好物化进
+// ts/node_modules 的机器上可见(legacy-peer-deps 安装则缺,5 个 TS2345/TS7006)。
+import type {} from '@deepseek-ai/dsh-session'
+import type { ToolExecutionResult, ToolExecutionToken } from '@deepseek-ai/dsh-tools'
+import { classifyTurn, TURN_HANDOFF_ETA_LABEL, turnPolicyFor, type TurnPolicy } from './turn-policy.ts'
+
+export const TURN_DEADLINE_SOFT = 'TURN_DEADLINE_SOFT'
+export const TURN_DEADLINE_EXHAUSTED = 'TURN_DEADLINE_EXHAUSTED'
+export const TURN_DEADLINE_HANDOFF = 'TURN_DEADLINE_HANDOFF'
+export const TURN_HANDOFF_SCHEMA = 'gotry_turn_handoff.v1' as const
+
+export interface TurnHandoffTicket {
+  schema: typeof TURN_HANDOFF_SCHEMA
+  id: string
+  objective: string
+  userMessage: string
+  requestedAt: string
+  etaLabel: string
+  status: 'open' | 'settled' | 'failed'
+  /** 结算时间(ISO);open 时缺省。 */
+  settledAt?: string
+  /** 结算交付物文件名(与工单同目录的 .deliverable.md)。 */
+  deliverableFile?: string
+  /** failed 时的稳定错误描述。 */
+  error?: string
+}
+
+/** 复访视图:工单事实 + 已结算交付物摘录(有界)。 */
+export interface TurnHandoffTicketView {
+  id: string
+  status: TurnHandoffTicket['status']
+  objective: string
+  requestedAt: string
+  etaLabel: string
+  settledAt?: string
+  error?: string
+  deliverableExcerpt?: string
+}
+
+export interface TurnDeadlineOptions {
+  /** When false the install call returns immediately with zero side effects. */
+  enabled?: boolean
+  /** Benchmark pin: routing is bypassed, every turn gets this exact policy. */
+  fixedPolicy?: TurnPolicy
+  /** Product: handoff ticket target root. Handoff degrades to converge when absent. */
+  stateRoot?: string
+  /** Wall-clock source — overridden by tests for determinism. */
+  now?: () => number
+}
+
+export async function writeTurnHandoffTicket(stateRoot: string, userMessage: string): Promise<TurnHandoffTicket> {
+  const ticket: TurnHandoffTicket = {
+    schema: TURN_HANDOFF_SCHEMA,
+    id: `th-${Date.now().toString(36)}-${randomUUID().slice(0, 6)}`,
+    objective: userMessage.length > 120 ? `${userMessage.slice(0, 120)}…` : userMessage,
+    userMessage,
+    requestedAt: new Date().toISOString(),
+    etaLabel: TURN_HANDOFF_ETA_LABEL,
+    status: 'open',
+  }
+  await writeTicketJson(stateRoot, ticket)
+  return ticket
+}
+
+function handoffDir(stateRoot: string): string {
+  const root = stateRoot === '.' ? process.cwd() : stateRoot
+  return join(root, 'gotry-state', 'turn-handoffs')
+}
+
+async function writeTicketJson(stateRoot: string, ticket: TurnHandoffTicket): Promise<string> {
+  const dir = handoffDir(stateRoot)
+  await mkdir(dir, { recursive: true })
+  const path = join(dir, `${ticket.id}.json`)
+  const tmp = `${path}.tmp`
+  await writeFile(tmp, JSON.stringify(ticket, null, 2), 'utf-8')
+  await rename(tmp, path)
+  return path
+}
+
+/**
+ * 结算工单:交付物落 `<id>.deliverable.md`(settled=规划产物;failed=诚实
+ * 失败说明),工单 json 原子更新 status/settledAt/deliverableFile/error。
+ */
+export async function settleTurnHandoffTicket(
+  stateRoot: string,
+  ticket: TurnHandoffTicket,
+  status: 'settled' | 'failed',
+  deliverable: string,
+  error?: string,
+): Promise<{ ticketPath: string; deliverablePath: string }> {
+  const dir = handoffDir(stateRoot)
+  await mkdir(dir, { recursive: true })
+  const deliverablePath = join(dir, `${ticket.id}.deliverable.md`)
+  const deliverableTmp = `${deliverablePath}.tmp`
+  await writeFile(deliverableTmp, deliverable, 'utf-8')
+  await rename(deliverableTmp, deliverablePath)
+  const settled: TurnHandoffTicket = {
+    ...ticket,
+    status,
+    settledAt: new Date().toISOString(),
+    deliverableFile: `${ticket.id}.deliverable.md`,
+    ...(error ? { error } : {}),
+  }
+  const ticketPath = await writeTicketJson(stateRoot, settled)
+  return { ticketPath, deliverablePath }
+}
+
+/** 复访查询:按请求时间倒序列出工单;settled 附交付物摘录(≤600 字)。 */
+export async function listTurnHandoffTickets(stateRoot: string): Promise<TurnHandoffTicketView[]> {
+  const dir = handoffDir(stateRoot)
+  let names: string[]
+  try {
+    names = await readdir(dir)
+  } catch {
+    return []
+  }
+  const views: TurnHandoffTicketView[] = []
+  for (const name of names) {
+    if (!name.endsWith('.json')) continue
+    try {
+      const raw = JSON.parse(await readFile(join(dir, name), 'utf-8')) as TurnHandoffTicket
+      if (raw?.schema !== TURN_HANDOFF_SCHEMA) continue
+      const view: TurnHandoffTicketView = {
+        id: raw.id,
+        status: raw.status,
+        objective: raw.objective,
+        requestedAt: raw.requestedAt,
+        etaLabel: raw.etaLabel,
+        ...(raw.settledAt ? { settledAt: raw.settledAt } : {}),
+        ...(raw.error ? { error: raw.error } : {}),
+      }
+      if (raw.status !== 'open' && raw.deliverableFile) {
+        try {
+          const text = await readFile(join(dir, raw.deliverableFile), 'utf-8')
+          view.deliverableExcerpt = text.length > 600 ? `${text.slice(0, 600)}…` : text
+        } catch { /* 交付物缺失时视图降级,不阻塞列表 */ }
+      }
+      views.push(view)
+    } catch { /* 单个坏工单不阻塞列表 */ }
+  }
+  views.sort((a, b) => (a.requestedAt < b.requestedAt ? 1 : -1))
+  return views
+}
+
+function resolveEnvPin(name: string): number | null {
+  const raw = process.env[name]
+  if (!raw) return null
+  const parsed = Number.parseInt(raw, 10)
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null
+}
+
+function convergenceContext(code: string, text: string) {
+  return {
+    id: randomUUID(),
+    role: 'user' as const,
+    content: [{ type: 'text' as const, text: `${code}: ${text}` }],
+    // 0.2.0-rc.2(V4 会话格式)移除 'plugin' source kind;运行时自产注入归 system-prompt。
+    source: { kind: 'system-prompt' as const },
+  }
+}
+
+function exhaustionResult(reason: string): ToolExecutionResult {
+  return {
+    isError: true,
+    error: {
+      message: reason,
+      info: { name: 'TurnDeadlineError', code: TURN_DEADLINE_EXHAUSTED },
+    },
+    content: [{ type: 'text', text: reason }],
+    additionalContexts: [convergenceContext(
+      TURN_DEADLINE_EXHAUSTED,
+      'No more tool dispatches are permitted in this turn. Produce the final answer from existing results.',
+    ) as never],
+  }
+}
+
+function handoffResult(ticket: TurnHandoffTicket): ToolExecutionResult {
+  const instruction = `Turn handed off to background planning. Async ticket ${ticket.id} created (ETA ${ticket.etaLabel}). Stop dispatching tools and tell the user in one short message: the deep planning continues in the background, the expected time, and to check back later (mention ticket ${ticket.id}).`
+  return {
+    isError: true,
+    error: {
+      message: `${TURN_DEADLINE_HANDOFF}: sync window exhausted for a deep-planning turn; ticket ${ticket.id}`,
+      info: { name: 'TurnDeadlineHandoff', code: TURN_DEADLINE_HANDOFF },
+    },
+    content: [{ type: 'text', text: `${TURN_DEADLINE_HANDOFF}: ${instruction}` }],
+    additionalContexts: [convergenceContext(TURN_DEADLINE_HANDOFF, instruction) as never],
+  }
+}
+
+type RestrictableTools = {
+  schemas?: () => Array<{ name: string }>
+  restrict?: (filter: { deny: string[] }) => () => void
+}
+
+type AgentTurnState = {
+  startedAt: number
+  policy: TurnPolicy
+  userMessage?: string
+}
+
+/**
+ * Install the runtime boundary, kept separate from the GoTry tool catalog so
+ * the actual Cordis waterfalls can be exercised without booting every tool.
+ */
+export function installTurnDeadline(ctx: Context, options: TurnDeadlineOptions = {}): void {
+  if (options.enabled === false) return
+
+  // Some offline contract tests intentionally provide a registration-only
+  // Context slice. They do not drive an agent loop, so there is no boundary
+  // to install and no reason to require an event bus.
+  if (typeof (ctx as unknown as { on?: unknown }).on !== 'function') return
+
+  const now = options.now ?? (() => Date.now())
+  // Test/benchmark seam only: pin the resolved numbers without touching the
+  // routed exit strategy. Product runs never set these.
+  const softPin = resolveEnvPin('GOTRY_TURN_DEADLINE_SOFT_MS')
+  const hardPin = resolveEnvPin('GOTRY_TURN_DEADLINE_HARD_MS')
+
+  const defaultPolicy = options.fixedPolicy ?? turnPolicyFor('sync-planning')
+  const routePolicy = (message: string): TurnPolicy => {
+    if (options.fixedPolicy) return { ...options.fixedPolicy }
+    const policy = turnPolicyFor(classifyTurn(message))
+    return { ...policy, softMs: softPin ?? policy.softMs, hardMs: hardPin ?? policy.hardMs }
+  }
+
+  const stateByAgent = new Map<string, AgentTurnState>()
+  const softExecutions = new Map<ToolExecutionToken, { agentId: string; exit: string }>()
+  const finalOnlyDisposers = new Map<string, () => void>()
+
+  const clearAgent = (agentId: string) => {
+    stateByAgent.delete(agentId)
+    for (const [token, owner] of softExecutions) {
+      if (owner.agentId === agentId) softExecutions.delete(token)
+    }
+    finalOnlyDisposers.get(agentId)?.()
+    finalOnlyDisposers.delete(agentId)
+  }
+
+  const enterFinalOnly = (agent: Agent) => {
+    const agentId = String(agent.id)
+    if (finalOnlyDisposers.has(agentId)) return
+    const globalTools = ctx.tools as unknown as RestrictableTools
+    const scopedTools = agent.ctx?.tools as unknown as RestrictableTools | undefined
+    if (typeof globalTools.schemas !== 'function' || typeof scopedTools?.restrict !== 'function') {
+      // No registry to suppress: subsequent tool calls in the same turn hit the
+      // same per-call denial branch and stay refused until the next turn.
+      return
+    }
+    const inheritedNames = globalTools.schemas()
+      .map(schema => schema.name)
+      .filter(name => name !== 'run_code')
+    if (inheritedNames.length === 0) return
+    finalOnlyDisposers.set(agentId, scopedTools.restrict({ deny: inheritedNames }))
+  }
+
+  // 事件主体是 session 对象;agent 归属同一 session 时共用同一预算键。
+  const keyOfAgent = (agent: Agent) => {
+    const session = (agent as unknown as { session?: { id?: unknown } }).session
+    return String(session?.id ?? agent.id)
+  }
+
+  ctx.on('session/event', (subject, event) => {
+    const agentId = String(subject.id)
+    if (event.type === 'turn/end') {
+      clearAgent(agentId)
+      return
+    }
+    if (event.type === 'turn/start') {
+      finalOnlyDisposers.get(agentId)?.()
+      finalOnlyDisposers.delete(agentId)
+      if (!stateByAgent.has(agentId)) {
+        stateByAgent.set(agentId, {
+          startedAt: now(),
+          policy: { ...defaultPolicy, softMs: softPin ?? defaultPolicy.softMs, hardMs: hardPin ?? defaultPolicy.hardMs },
+        })
+      }
+      return
+    }
+    if (event.type === 'user/message') {
+      // dsh 事件载荷在 event.data 下(benchmark-agent-conformance 同型读法)。
+      const message = (event as {
+        data?: { source?: { kind?: string }; content?: ReadonlyArray<{ type?: string; text?: string }> }
+      }).data
+      if (message?.source?.kind !== 'user') return
+      const text = (message.content ?? []).find(block => block.type === 'text')?.text ?? ''
+      if (!text.trim()) return
+      // 每个 user 消息 = 新的预算:路由分类 + 时钟重置。plugin/skill 注入
+      // 的 user/message(source.kind !== 'user')不参与路由。
+      stateByAgent.set(agentId, { startedAt: now(), policy: routePolicy(text), userMessage: text })
+    }
+  })
+  ctx.on('session/disposed', subject => clearAgent(String(subject.id)))
+
+  ctx.on('tools/execute', (exec, next) => {
+    // Programmatic/direct calls are not part of a model planner turn.
+    if (!exec.agent) return next()
+    const agentId = keyOfAgent(exec.agent)
+    const state = stateByAgent.get(agentId)
+      ?? { startedAt: now(), policy: { ...defaultPolicy, softMs: softPin ?? defaultPolicy.softMs, hardMs: hardPin ?? defaultPolicy.hardMs } }
+    stateByAgent.set(agentId, state)
+
+    const elapsed = now() - state.startedAt
+    if (elapsed > state.policy.hardMs) {
+      // Synchronous schema suppression so same-step follow-up calls cannot
+      // loop on refusal results (the 2026-09-02 trajectory failure).
+      enterFinalOnly(exec.agent)
+      if (state.policy.exit === 'handoff' && state.userMessage && options.stateRoot) {
+        return writeTurnHandoffTicket(options.stateRoot, state.userMessage)
+          .then(ticket => handoffResult(ticket))
+          .catch(() => exhaustionResult(
+            `${TURN_DEADLINE_EXHAUSTED}: hard deadline ${state.policy.hardMs}ms reached (ticket persistence failed; degraded to converge)`,
+          ))
+      }
+      return Promise.resolve(exhaustionResult(
+        `${TURN_DEADLINE_EXHAUSTED}: turn exceeded hard deadline of ${state.policy.hardMs}ms (elapsed ${elapsed}ms); provide a final answer using existing results`,
+      ))
+    }
+    if (elapsed > state.policy.softMs) {
+      softExecutions.set(exec.token, { agentId, exit: state.policy.exit })
+    }
+    return next()
+  })
+
+  ctx.on('tools/post-execute', (exec, _result, next) => {
+    return next().then(decision => {
+      const owner = softExecutions.get(exec.token)
+      if (!owner) return decision
+      softExecutions.delete(exec.token)
+      const text = owner.exit === 'handoff'
+        ? 'Turn has crossed the soft deadline of a deep-planning turn. Wrap up context gathering now; the turn will hand off to background planning at the hard deadline.'
+        : 'Turn has crossed the soft deadline. Stop dispatching new tools and produce the final answer from gathered evidence.'
+      return {
+        ...decision,
+        additionalContexts: [
+          ...(decision.additionalContexts ?? []),
+          convergenceContext(TURN_DEADLINE_SOFT, text) as never,
+        ],
+      }
+    })
+  })
+}

package/ts/src/turn-policy.ts

@@ -0,0 +1,154 @@
+/**
+ * Per-turn routing & time allocation (ADR-24 v2).
+ *
+ * 用户主观时间是产品路径唯一的预算:复杂度决定**出口结构**(converge /
+ * handoff),时间只是在所选结构内的资源分配。路由在 user/message 落地时
+ * 一次完成,纯函数、零 LLM、零 IO——控制面判定必须是确定性组件
+ * (stage1 责任铁律;ADR-9 同型先例),且不能花它要分配的资源。
+ *
+ * Tier 0(消息内禀)是 v1 的全部规则输入;Tier 1(账本读回)只在
+ * handoff 落单时用于工单上下文,不参与分类。`loop.ts` 的 isComplex 是
+ * S5 循环架构内的访谈后复核,不在产品路径上,不进本层。
+ */
+
+export type TaskClass = 'quick' | 'sync-planning' | 'deep-planning'
+
+export type TurnExit = 'converge' | 'handoff'
+
+export interface TurnPolicy {
+  /** 软阈:注入收敛/转出提示,不拦截。 */
+  softMs: number
+  /** 硬阈:拒绝后续工具派发,按 exit 语义出口。 */
+  hardMs: number
+  /** 硬阈出口:converge=用已有证据作答;handoff=落工单转后台并告知用户。 */
+  exit: TurnExit
+}
+
+/** v1 阈值表:数据不是代码;评测/部署换表不换执行器。 */
+export const TURN_POLICIES: Record<TaskClass, TurnPolicy> = {
+  // quick:实际上限只是安全网——quick 类历史上没有发散记录。
+  quick: { softMs: 120_000, hardMs: 180_000, exit: 'converge' },
+  'sync-planning': { softMs: 300_000, hardMs: 600_000, exit: 'converge' },
+  // deep-planning:同步窗口只够"摸底 + 落单承诺",到点必须转后台。
+  'deep-planning': { softMs: 120_000, hardMs: 240_000, exit: 'handoff' },
+}
+
+export const TURN_HANDOFF_ETA_LABEL = '约 1 小时'
+
+/** 约束词表:只作弱信号(命中≥2 才可能推 deep);新增词=加一行+一测。 */
+export const TURN_CONSTRAINT_LEXICON = [
+  '婚礼', '婚宴', '回门', '订婚',
+  'IRW', 'irw',
+  '请假', '年假', '调休', '额度',
+  '签证', '同行', '伴侣', '亲子', '带娃', '父母', '团建', '出差',
+  '红眼', '中转', '联程', '多城',
+] as const
+
+export interface TurnSignals {
+  messageLength: number
+  /** 消息内的绝对日期(已过 1-12/1-31 校验)。 */
+  absoluteDates: Array<{ year: number | null; month: number; day: number }>
+  /** 绝对日期≥2 时为极差天数;否则为跨度词天数;都没有则 null。 */
+  spanDays: number | null
+  /** 命中的约束词(去重,保留词表序)。 */
+  constraintHits: string[]
+}
+
+const CN_DIGITS: Record<string, number> = {
+  一: 1, 二: 2, 两: 2, 三: 3, 四: 4, 五: 5, 六: 6, 七: 7, 八: 8, 九: 9, 十: 10,
+}
+
+function dayCount(year: number | null, month: number, day: number): number {
+  // 无年份时按平年锚定:跨度计算只需要差值,月份跨年场景 v1 不覆盖。
+  const y = year ?? 1970
+  return Date.UTC(y, month - 1, day) / 86_400_000
+}
+
+/** 跨度词 → 估算天数;按声明强度取第一个命中,v1 不做组合。 */
+function spanWordDays(message: string): number | null {
+  if (/十几天/.test(message)) return 12
+  if (/半个月/.test(message)) return 15
+  if (/一个月/.test(message)) return 30
+  const week = message.match(/[一两]个?(?:星期|周)/)
+  if (week) return week[0].startsWith('两') ? 14 : 7
+  const dayMatch = message.match(/([0-9一二两三四五六七八九十]+)\s*天/)
+  if (dayMatch) {
+    const raw = dayMatch[1]
+    if (/^[0-9]+$/.test(raw)) return Math.min(Number.parseInt(raw, 10), 60)
+    if (CN_DIGITS[raw] !== undefined) return Math.min(CN_DIGITS[raw], 60)
+  }
+  return null
+}
+
+export function extractTurnSignals(message: string): TurnSignals {
+  const absoluteDates: TurnSignals['absoluteDates'] = []
+
+  // 完整日期先摘除,避免 2026-10-03 再被月/日模式重复计数。
+  let rest = message.replace(
+    /(?<!\d)(\d{4})[年\-.\/](\d{1,2})[月\-.\/](\d{1,2})日?(?!\d)/g,
+    (_all, y: string, m: string, d: string) => {
+      const month = Number.parseInt(m, 10)
+      const day = Number.parseInt(d, 10)
+      if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+        absoluteDates.push({ year: Number.parseInt(y, 10), month, day })
+      }
+      return ' '
+    },
+  )
+  rest = rest.replace(
+    /(?<!\d)(\d{1,2})月(\d{1,2})日?(?!\d)/g,
+    (_all, m: string, d: string) => {
+      const month = Number.parseInt(m, 10)
+      const day = Number.parseInt(d, 10)
+      if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+        absoluteDates.push({ year: null, month, day })
+      }
+      return ' '
+    },
+  )
+  rest = rest.replace(
+    /(?<!\d)(\d{1,2})[.\/](\d{1,2})(?!\d)/g,
+    (_all, m: string, d: string) => {
+      const month = Number.parseInt(m, 10)
+      const day = Number.parseInt(d, 10)
+      if (month >= 1 && month <= 12 && day >= 1 && day <= 31) {
+        absoluteDates.push({ year: null, month, day })
+      }
+      return ' '
+    },
+  )
+
+  const constraintHits = TURN_CONSTRAINT_LEXICON.filter(word => message.includes(word))
+
+  let spanDays: number | null = null
+  if (absoluteDates.length >= 2) {
+    const counts = absoluteDates.map(d => dayCount(d.year, d.month, d.day))
+    spanDays = Math.max(...counts) - Math.min(...counts)
+  } else {
+    spanDays = spanWordDays(message)
+  }
+
+  return { messageLength: message.length, absoluteDates, spanDays, constraintHits }
+}
+
+/**
+ * 分类规则(有序,可表测):长跨度或多约束 → deep(转后台);无日期无约束
+ * 且短 → quick;其余落默认中间档 sync-planning。误分有界:三态出口保证
+ * 最坏结局是"本可当面答的被转了后台"(下一轮可救),而非流死掉。
+ */
+export function classifyTurn(message: string): TaskClass {
+  const s = extractTurnSignals(message)
+  if (s.spanDays !== null && s.spanDays >= 7) return 'deep-planning'
+  if (s.absoluteDates.length >= 2 && s.constraintHits.length >= 1) return 'deep-planning'
+  if (s.constraintHits.length >= 2 && (s.absoluteDates.length >= 1 || s.spanDays !== null)) {
+    return 'deep-planning'
+  }
+  if (s.absoluteDates.length === 0 && s.constraintHits.length === 0 && s.spanDays === null && s.messageLength <= 60) {
+    return 'quick'
+  }
+  return 'sync-planning'
+}
+
+export function turnPolicyFor(taskClass: TaskClass): TurnPolicy {
+  return { ...TURN_POLICIES[taskClass] }
+}