@danceiny/gotry 0.0.1-rc.18 → 0.0.1-rc.20

package/ts/src/loop.ts

@@ -1,5 +1,5 @@
 /**
- * Stage 1 对话循环(S2 段1,docs/stage1-top-down-design.md §2.3)。
+ * Stage 1 对话循环(S2 段1,docs/design/stage1-top-down-design.md §2.3)。
  *
  * 自顶向下:循环只依赖两个端口——LlmPort(mock/真)与确定性工具(interview_next)。
  * 求解/渲染接线是 S2 后续段;本段验收:重放用户开场白,系统一轮内完成

package/ts/src/state-ledger.ts

@@ -1,5 +1,5 @@
 /**
- * 事务化状态账本(ADR-15,docs/transactional-state-rfc.md):
+ * 事务化状态账本(ADR-15,docs/rfc/transactional-state-rfc.md):
  * 「文件即权威」→「单文件 SQLite 账本即权威」。
  *
  *   - events 表 = 唯一权威(append-only;语义幂等键物理化为 UNIQUE 索引)

package/ts/src/turn-deadline.ts

@@ -0,0 +1,365 @@
+/**
+ * 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}` }],
+    source: { kind: 'plugin' as const, plugin: 'gotry-turn-deadline' },
+  }
+}
+
+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?: Array<{ 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] }
+}

package/ts/src/wish-pool.ts

@@ -10,16 +10,19 @@ export interface WishPoolEntry {
   wish_id?: string | unknown
   name?: string | unknown
   reason?: string | unknown
-  conditions?: { days?: number; budget_cny?: number; best_months?: number[] } | unknown
+  conditions?: { days?: number; budget_cny?: number; best_months?: number[]; channels?: string[] } | unknown
   muted?: boolean | unknown
   added_at?: string | unknown
 }
 
-/** 召回窗口上下文:用户当前可支配的天数/预算 + 目标月份 */
+/** 召回窗口上下文:用户当前可支配的天数/预算 + 目标月份;
+ *  channelDown(外部事件接缝第 2 段,seam 设计 §3.3/§6②)=当前处于 down 的通道名
+ *  集合(来自 channel-health.jsonl 持久面;缺省=不启用通道否证,旧调用方零影响)。 */
 export interface WishMatchContext {
   days?: number
   budgetCny?: number
   month?: number
+  channelDown?: ReadonlySet<string>
 }
 
 export interface WishMatch {
@@ -30,9 +33,19 @@ export interface WishMatch {
   hits: string[]
 }
 
-/** 条件评分:days/budget 为「窗口 ≥ 条件」,month 为「命中 best_months」;条件缺失的项不计分 */
+/**
+ * 条件评分:days/budget 为「窗口 ≥ 条件」,month 为「命中 best_months」;条件缺失的项不计分。
+ * 通道否证(接缝第 2 段):conditions.channels 命名依赖通道,任一处于 down 且
+ * ctx.channelDown 已提供 → 否证成行条件,返回 null(当下推这个愿望=体验差);
+ * 通道全健康或健康面缺席(未传 channelDown)不加分不否——「佐证」渲染面留后续切片。
+ */
 export function scoreWishMatch(entry: WishPoolEntry, ctx: WishMatchContext): WishMatch | null {
-  const c = (entry.conditions ?? {}) as { days?: number; budget_cny?: number; best_months?: number[] }
+  const c = (entry.conditions ?? {}) as { days?: number; budget_cny?: number; best_months?: number[]; channels?: string[] }
+  if (ctx.channelDown && Array.isArray(c.channels)) {
+    for (const ch of c.channels) {
+      if (typeof ch === 'string' && ctx.channelDown.has(ch)) return null
+    }
+  }
   const hits: string[] = []
   if (typeof ctx.days === 'number' && typeof c.days === 'number' && ctx.days >= c.days) hits.push(`days≥${c.days}`)
   if (typeof ctx.budgetCny === 'number' && typeof c.budget_cny === 'number' && ctx.budgetCny >= c.budget_cny) hits.push(`budget≥${c.budget_cny}`)