dsh-session-bridge 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-bridge",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "会话桥（dsh-session-bridge）：通过提示词创建新的主会话（顶层 UI 会话）、向任意会话发送消息、等待会话的下一条回复、读取会话消息，并按会话名或 id 跨工作区查找会话；此外支持监控/调度主任务与归档会话。",
   "private": false,
   "type": "module",

package/src/core.ts

@@ -60,6 +60,32 @@ export interface BridgeFindItem {
   agentPreset?: string
 }
 
+/**
+ * 兼容读取不同 dsh-session 版本上的会话事件：
+ * - 旧版 `Session` 暴露 `get events(): readonly SessionEvent[]`；
+ * - 新版（如宿主实际运行的 0.1.2-rc.x）将 `get events` 改为
+ *   `snapshotEvents(fromSeq?, toSeqExclusive?)` 方法——`.events` 直接读取会
+ *   得到 `undefined`，对 for...of 迭代即抛 `events is not iterable`。
+ * 两者都读不到（或 session 不存在）时回退为空数组，绝不抛迭代错误。
+ */
+export function sessionEvents(session: unknown): readonly SessionEvent[] {
+  const s = session as {
+    events?: readonly SessionEvent[]
+    snapshotEvents?: (fromSeq?: number, toSeqExclusive?: number) => readonly SessionEvent[]
+  } | null | undefined
+  if (s === null || s === undefined) return []
+  if (Array.isArray(s.events)) return s.events
+  if (typeof s.snapshotEvents === 'function') {
+    try { return s.snapshotEvents() } catch { return [] }
+  }
+  return []
+}
+
+/** 规约任意"事件列表"值为数组（非数组 → []），避免 events is not iterable。 */
+export function asEventList(events: unknown): readonly SessionEvent[] {
+  return Array.isArray(events) ? events : []
+}
+
 /** agent.followup / steer 接受的用户消息值。 */
 export function userMessage(text: string): unknown {
   return {
@@ -82,6 +108,19 @@ function blockText(content: unknown): string | undefined {
   return parts.length === 0 ? undefined : parts.join('\n')
 }
 
+/** 提取指定类型的 content block 文本（如 reasoning），用于从消息 content 里读出思维链。 */
+function blockTextByType(content: unknown, wantedType: string): string | undefined {
+  if (!Array.isArray(content)) return undefined
+  const parts: string[] = []
+  for (const raw of content) {
+    const block = raw as { type?: unknown; text?: unknown } | null
+    if (block !== null && typeof block === 'object' && block.type === wantedType && typeof block.text === 'string') {
+      if (block.text !== '') parts.push(block.text)
+    }
+  }
+  return parts.length === 0 ? undefined : parts.join('\n')
+}
+
 function countImages(content: unknown): number {
   if (!Array.isArray(content)) return 0
   let n = 0
@@ -104,8 +143,9 @@ function toolNamesOf(toolCalls: unknown): string[] {
 
 /** 折叠会话事件日志为可读消息行（跳过非 user 来源与空消息）。 */
 export function foldMessages(events: readonly SessionEvent[]): BridgeMessageRow[] {
+  const list = asEventList(events)
   const rows: BridgeMessageRow[] = []
-  for (const event of events) {
+  for (const event of list) {
     if (event.type === 'user/message') {
       const source = (event.data as { source?: { kind?: string } }).source
       if (source !== undefined && source.kind !== 'user') continue
@@ -115,7 +155,9 @@ export function foldMessages(events: readonly SessionEvent[]): BridgeMessageRow[
     } else if (event.type === 'assistant/message') {
       const message = event.data.message as { content?: unknown; reasoning?: unknown; toolCalls?: unknown } | null
       const text = message === null ? undefined : blockText(message.content)
-      const reasoning = message === null ? undefined : blockText(message.reasoning)
+      // 思维链是 content 里 type:'reasoning' 的块；老版本曾把取舍放在 message.reasoning 字段，
+      // 两者都读，优先 content 块（当前 dsh-llm 的 AssistantMessage 无独立 reasoning 字段）。
+      const reasoning = message === null ? undefined : (blockTextByType(message.content, 'reasoning') ?? blockText(message.reasoning))
       const images = message === null ? 0 : countImages(message.content)
       const toolCalls = message === null ? [] : toolNamesOf(message.toolCalls)
       if (text === undefined && reasoning === undefined && toolCalls.length === 0) continue
@@ -129,13 +171,141 @@ export function foldMessages(events: readonly SessionEvent[]): BridgeMessageRow[
   return rows
 }
 
+/** 一个已完成的输出段落：一次 assistant step 定型的 assistant/message（turn 中途即可读，无需等整个 turn）。 */
+export interface BridgeSegment {
+  seq: number
+  time: number
+  turn: number
+  step: number
+  text?: string
+  reasoning?: string
+  toolCalls: string[]
+  openTurn: boolean
+}
+
+/** 按已完成输出段落折叠事件日志：每个 assistant/message 割一段，返回 sinceSeq 后的所有段落（事件序）。 */
+export function segmentsSince(events: readonly SessionEvent[], sinceSeq = 0): BridgeSegment[] {
+  const list = asEventList(events)
+  const out: BridgeSegment[] = []
+  let openTurn = false
+  for (const event of list) {
+    if (event.type === 'turn/start') { openTurn = true; continue }
+    if (event.type === 'turn/end') { openTurn = false; continue }
+    if (event.type !== 'assistant/message') continue
+    if (event.seq <= sinceSeq) continue
+    const message = event.data.message as { content?: unknown; reasoning?: unknown; toolCalls?: unknown } | null
+    const text = message === null ? undefined : blockText(message.content)
+    const reasoning = message === null ? undefined : (blockTextByType(message.content, 'reasoning') ?? blockText(message.reasoning))
+    const toolCalls = message === null ? [] : toolNamesOf(message.toolCalls)
+    const turn = (event.data as { turn?: unknown })?.turn
+    const step = (event.data as { step?: unknown })?.step
+    const seg: BridgeSegment = {
+      seq: event.seq,
+      time: event.time,
+      turn: typeof turn === 'number' ? turn : 0,
+      step: typeof step === 'number' ? step : 0,
+      toolCalls,
+      openTurn,
+    }
+    if (text !== undefined) seg.text = text
+    if (reasoning !== undefined) seg.reasoning = reasoning
+    out.push(seg)
+  }
+  return out
+}
+
+/** 取自 sinceSeq 之后最新一个已完成输出段落（无则 null）。 */
+export function latestSegmentSince(events: readonly SessionEvent[], sinceSeq = 0): BridgeSegment | null {
+  const segs = segmentsSince(events, sinceSeq)
+  return segs.length === 0 ? null : (segs[segs.length - 1] ?? null)
+}
+
+/** 实时思维链切片：一个 live 会话当前"进行中"的增量推理与文本。 */
+export interface CoTLiveSlice {
+  /** 产生该推理的 turn。 */
+  turn: number
+  /** 产生该推理的 step。 */
+  step: number
+  /** 自最近一条已定型 assistant 消息以来累积的进行中推理文本（reasoning-delta 拼接）。 */
+  reasoning: string
+  /** 同窗口累积的进行中文本增量（text-delta 拼接）。 */
+  text: string
+  /** 本切片覆盖到的最大事件 seq（供增量轮询记住游标）。 */
+  seq: number
+  /** 最近一次事件时间戳。 */
+  time: number
+}
+
+/**
+ * 对一个 live 会话的事件日志折叠出其"实时思维链"：
+ * - 优先聚合流式 assistant/chunk 事件里的 reasoning-delta（turn 中途即可见、增量，
+ *   这正是监控思维链并按规则提前终止所需的粒度）；
+ * - 同时聚合同窗口的 text-delta 增量；
+ * - 若没有进行中的 chunk（会话空闲、或该 provider 不流式推理/无推理），返回 null，
+ *   调用方应回落为 foldMessages 里的已定型 message.reasoning。
+ * 纯读、无副作用；事件形状不做任何假设，缺失/异常一律安全处理。
+ */
+export function liveReasoningSnapshot(events: readonly SessionEvent[]): CoTLiveSlice | null {
+  const list = asEventList(events)
+  // 只累积"最近一条已定型 assistant/message 之后"的流式增量（当前 in-flight 窗口），
+  // 避免把历史每一轮的思维链都拼接进来。turn/step 记录窗口内最近的 chunk 归属。
+  let lastFinalizedSeq = -1
+  let reasoning = ''
+  let text = ''
+  let seq = -1
+  let time = 0
+  let turn = 0
+  let step = 0
+  let foundDelta = false
+  for (const event of list) {
+    if (event.type === 'assistant/message') {
+      lastFinalizedSeq = event.seq
+      continue
+    }
+    if (event.type !== 'assistant/chunk') continue
+    if (event.seq <= lastFinalizedSeq) continue
+    const data = event.data as { turn?: unknown; step?: unknown; chunk?: unknown } | null | undefined
+    if (data === null || data === undefined || typeof data !== 'object') continue
+    const c = data.chunk as { type?: unknown; text?: unknown } | null
+    if (c === null || typeof c !== 'object' || typeof c.type !== 'string') continue
+    if (c.type === 'reasoning-delta' || c.type === 'text-delta') {
+      if (typeof c.text !== 'string') continue
+      if (c.type === 'reasoning-delta') reasoning += c.text
+      else text += c.text
+      if (typeof data.turn === 'number') turn = data.turn
+      if (typeof data.step === 'number') step = data.step
+      foundDelta = true
+      if (event.seq > seq) seq = event.seq
+      if (event.time > time) time = event.time
+    }
+  }
+  if (!foundDelta) return null
+  return { turn, step, reasoning, text, seq, time }
+}
+
+/** 思维链尾巴默认截断上限（字符）。 */
+export const REASONING_TAIL_LIMIT = 4000
+
+/**
+ * 组装一条受字符上限约束的"思维链尾巴"用于展示/摘要：
+ * 优先进行中的 liveReasoning，否则最近已定型的 lastReasoning；
+ * 超出上限时截断并附省略标记。两者皆无返回 undefined。
+ */
+export function reasoningTailOf(liveReasoning: string | undefined, lastReasoning: string | undefined, limit = REASONING_TAIL_LIMIT): string | undefined {
+  const source = liveReasoning ?? lastReasoning
+  if (source === undefined || source === '') return undefined
+  if (source.length <= limit) return source
+  return source.slice(0, limit) + '…'
+}
+
 /**
  * 会话标题：优先 session/title 事件（last-wins，与 UI 一致）；
  * 无标题事件时回落为第一条用户消息（截断 80 字符）。
  */
 export function titleOf(events: readonly SessionEvent[]): string | undefined {
+  const list = asEventList(events)
   let title: string | undefined
-  for (const event of events) {
+  for (const event of list) {
     const raw = event as unknown as { type: string; data: { title?: unknown } }
     if (raw.type === 'session/title') {
       const t = raw.data.title
@@ -143,7 +313,7 @@ export function titleOf(events: readonly SessionEvent[]): string | undefined {
     }
   }
   if (title !== undefined) return title
-  for (const event of events) {
+  for (const event of list) {
     if (event.type === 'user/message') {
       const source = (event.data as { source?: { kind?: string } }).source
       if (source !== undefined && source.kind !== 'user') continue
@@ -159,8 +329,9 @@ export function titleOf(events: readonly SessionEvent[]): string | undefined {
 
 /** 日志最大事件序号。 */
 export function maxSeq(events: readonly SessionEvent[]): number {
+  const list = asEventList(events)
   let m = -1
-  for (const event of events) if (event.seq > m) m = event.seq
+  for (const event of list) if (event.seq > m) m = event.seq
   return m
 }
 
@@ -174,6 +345,8 @@ export interface WaitForReplyOptions {
   timeoutMs: number
   signal?: AbortSignal
   requireTurnEnd?: boolean
+  /** true 时等待到 baseline 之后出现一个“新完成的输出段落”（assistant/message），立即返回该段，不等整个 turn。 */
+  waitForSegment?: boolean
 }
 
 /**
@@ -192,33 +365,48 @@ export async function waitForReply(opts: WaitForReplyOptions): Promise<BridgeWai
   const started = Date.now()
   const deadline = started + opts.timeoutMs
   const requireTurnEnd = opts.requireTurnEnd ?? false
+  const waitForSegment = opts.waitForSegment ?? false
   let latest: BridgeMessageRow | null = null
   let textReply: BridgeMessageRow | null = null
+  let segment: BridgeSegment | null = null
   let turnEnded = false
   for (;;) {
     if (opts.signal !== undefined && opts.signal.aborted) break
-    const events = opts.session.events
+    const events = sessionEvents(opts.session)
     for (const row of foldMessages(events)) {
       if (row.seq <= opts.baselineSeq || row.role !== 'assistant') continue
       if (latest === null || row.seq > latest.seq) latest = row
       if (row.text !== undefined && (textReply === null || row.seq > textReply.seq)) textReply = row
     }
+    if (waitForSegment) {
+      const seg = latestSegmentSince(events, opts.baselineSeq)
+      if (seg !== null && (segment === null || seg.seq > segment.seq)) segment = seg
+    }
     if (requireTurnEnd && latest !== null) {
       for (const event of events) {
         if (event.seq > latest.seq && event.type === 'turn/end') { turnEnded = true; break }
       }
     }
-    const done = requireTurnEnd ? (latest !== null && turnEnded) : textReply !== null
+    let done: boolean
+    if (requireTurnEnd) done = latest !== null && turnEnded
+    else if (waitForSegment) done = segment !== null
+    else done = textReply !== null
     if (done) break
     if (Date.now() >= deadline) break
     await sleep(100)
   }
-  const message = textReply ?? latest
+  // 段落模式返回该段（把 reasoning 并进返回行，便于“按段落读思维链”）；否则返回最新文本行。
+  let message: BridgeMessageRow | null = waitForSegment && segment !== null ? {
+    seq: segment.seq, time: segment.time, role: 'assistant', images: 0,
+    ...(segment.text !== undefined ? { text: segment.text } : {}),
+    ...(segment.reasoning !== undefined ? { reasoning: segment.reasoning } : {}),
+    ...(segment.toolCalls.length > 0 ? { toolCalls: segment.toolCalls } : {}),
+  } : (textReply ?? latest)
   return {
     message,
     seq: message === null ? opts.baselineSeq : message.seq,
     turnEnded,
-    timedOut: requireTurnEnd ? (latest !== null && !turnEnded) : textReply === null,
+    timedOut: requireTurnEnd ? (latest !== null && !turnEnded) : waitForSegment ? segment === null : textReply === null,
     aborted: opts.signal !== undefined && opts.signal.aborted,
     waitedMs: Date.now() - started,
   }
@@ -313,6 +501,12 @@ export interface BridgeStatusSnapshot {
   nextStepCount: number
   /** 最新一条带文本的 assistant 回复。 */
   lastAssistantText?: string
+  /** 最新一条已定型 assistant 消息的推理（reasoning content block）。 */
+  lastReasoning?: string
+  /** 进行中的实时思维链增量（reasoning-delta 拼接；无进行中流时为 undefined）。 */
+  liveReasoning?: string
+  /** 极紧凑的思维链尾巴：liveReasoning 优先、否则 lastReasoning，截断至 reasoningTailLimit。 */
+  reasoningTail?: string
   /** 折叠后的消息总数。 */
   messageCount: number
   /** 最近几条消息（默认 8）。 */
@@ -324,7 +518,7 @@ export interface BridgeStatusSnapshot {
  * 纯读，无副作用。用于 `session_bridge_status`。
  */
 export function statusSnapshot(ctx: Context, agent: LiveAgentLike): BridgeStatusSnapshot {
-  const events = agent.session.events
+  const events = sessionEvents(agent.session)
   const rows = foldMessages(events)
   let lastActivityAt: number | null = null
   let lastTurn = 0
@@ -340,13 +534,18 @@ export function statusSnapshot(ctx: Context, agent: LiveAgentLike): BridgeStatus
   }
   const recent = rows.slice(-8)
   let lastAssistantText: string | undefined
+  let lastReasoning: string | undefined
   for (let i = rows.length - 1; i >= 0; i -= 1) {
     const row = rows[i]
-    if (row !== undefined && row.role === 'assistant' && row.text !== undefined) {
-      lastAssistantText = row.text
-      break
+    if (row !== undefined && row.role === 'assistant') {
+      if (lastAssistantText === undefined && row.text !== undefined) lastAssistantText = row.text
+      if (lastReasoning === undefined && row.reasoning !== undefined) lastReasoning = row.reasoning
+      if (lastAssistantText !== undefined && lastReasoning !== undefined) break
     }
   }
+  const live = liveReasoningSnapshot(events)
+  const liveReasoning = live !== null && live.reasoning !== '' ? live.reasoning : undefined
+  const reasoningTail = reasoningTailOf(liveReasoning, lastReasoning)
   const inbox = agent.inbox
   const cwd = agent.session.header.cwd
   return {
@@ -364,6 +563,9 @@ export function statusSnapshot(ctx: Context, agent: LiveAgentLike): BridgeStatus
     nextTurnCount: inbox?.nextTurn?.length ?? 0,
     nextStepCount: inbox?.nextStep?.length ?? 0,
     ...(lastAssistantText === undefined ? {} : { lastAssistantText }),
+    ...(lastReasoning === undefined ? {} : { lastReasoning }),
+    ...(liveReasoning === undefined ? {} : { liveReasoning }),
+    ...(reasoningTail === undefined ? {} : { reasoningTail }),
     messageCount: rows.length,
     recent,
   }

package/src/monitor.ts

@@ -40,6 +40,32 @@ export interface MonitorConfig {
   logFile?: string
   /** 监控会话的说明，仅用于展示。 */
   label?: string
+  /** 思维链（CoT）规则：对实时推理/文本做 contains/not-contains 匹配，持续命中达 cotMinHits 后触发 steer 或 cancel。 */
+  coTRules?: CoTRule[]
+  /** 一条规则连续命中多少个 tick 才触发（默认 1 = 立即）。 */
+  cotMinHits?: number
+}
+
+/** 一条思维链规则：匹配实时链的内容并触发动作。 */
+export interface CoTRule {
+  /** contains = 匹配内容必须包含 value；not-contains = 必须不含 value。 */
+  match: 'contains' | 'not-contains'
+  /** 在哪个字段上匹配：reasoning（思维链）/ text（回复文本）/ both（任一）。 */
+  field: 'reasoning' | 'text' | 'both'
+  /** 匹配的关键词（非空）。 */
+  value: string
+  /** 触发动作：cancel 立即终止会话；steer 注入一条用户消息引导。 */
+  action: 'steer' | 'cancel'
+  /** steer 时的注入文案（缺省用默认催办文案）。 */
+  message?: string
+}
+
+/** 一条 CoT 规则的连续命中计数（防单次 tick 误触发 & 防重复触发）。 */
+export interface CoTRuleState {
+  hits: number
+  lastFiredAt: number | null
+  lastMatch: boolean
+  lastSubject: string
 }
 
 export interface MonitorEntryState {
@@ -47,11 +73,14 @@ export interface MonitorEntryState {
   startedAt: number
   lastTickAt: number
   stuckCount: number
-  lastAction: 'none' | 'steer' | 'cancel' | 'done' | 'lost' | 'offtrack' | 'steady'
+  lastAction: 'none' | 'steer' | 'cancel' | 'done' | 'lost' | 'offtrack' | 'steady' | 'cot-steer' | 'cot-cancel'
   lastActionAt: number | null
   lastNote: string
   done: boolean
   cycles: number
+  cot: {
+    rules: { [key: string]: CoTRuleState }
+  }
 }
 
 const SCAN_MS = 5000
@@ -77,6 +106,13 @@ export class SessionMonitor {
   start(config: MonitorConfig): MonitorEntryState {
     const existing = this.entries.get(config.sessionId)
     const now = Date.now()
+    const cotInit: MonitorEntryState['cot'] = {
+      rules: (config.coTRules ?? []).reduce<Record<string, CoTRuleState>>((acc, rule, index) => {
+        const key = String(index) + ':' + rule.match + ':' + rule.field + ':' + rule.value
+        acc[key] = { hits: 0, lastFiredAt: null, lastMatch: false, lastSubject: '' }
+        return acc
+      }, {}),
+    }
     const entry: MonitorEntryState = existing !== undefined
       ? { ...existing, config, lastTickAt: now }
       : {
@@ -89,7 +125,9 @@ export class SessionMonitor {
         lastNote: '监控已启动',
         done: false,
         cycles: 0,
+        cot: cotInit,
       }
+    if (entry.cot === undefined) entry.cot = cotInit
     this.entries.set(config.sessionId, entry)
     this.ensureTimer()
     this.log(entry, 'monitor start session=' + config.sessionId + ' interval=' + config.intervalMs
@@ -232,6 +270,11 @@ export class SessionMonitor {
       return
     }
 
+    // 4b) 思维链（CoT）规则检查：对实时推理/文本做匹配，持续命中则 steer/cancel。
+    // 与卡住逻辑正交：即使会话在推进，只要思维链不符合规则也可提前终止/纠偏。
+    const cotHandled = this.evaluateCoTRules(entry, snapshot, sessionId)
+    if (cotHandled) return
+
     // 5) 正常推进：重置卡住计数。
     if (entry.stuckCount !== 0) entry.stuckCount = 0
     entry.lastAction = 'steady'
@@ -262,6 +305,88 @@ export class SessionMonitor {
     return keywords.some((kw) => kw !== '' && text.includes(kw))
   }
 
+  /**
+   * 评估思维链（CoT）规则。规则只对 live 会话有意义：running 时用进行中的
+   * reasoning-delta 流，空闲时回落到已定型 lastReasoning。not-contains 规则作用在
+   * reasoning 字段时，若该会话本就没有推理（非推理模型/尚未产出），不判定为命中，
+   * 避免误 cancel 一个根本不产生思维链的会话。
+   * @returns true 表示本 tick 已被某条规则触发并处理（steer/cancel），调用方应 return。
+   */
+  private evaluateCoTRules(entry: MonitorEntryState, snapshot: BridgeStatusSnapshot, sessionId: string): boolean {
+    const rules = entry.config.coTRules ?? []
+    if (rules.length === 0) return false
+    const minHits = entry.config.cotMinHits ?? 1
+
+    // 评估主体：进行中的实时推理/文本，否则已定型的上次推理/回复。
+    const hasLive = (snapshot.liveReasoning ?? '') !== ''
+    const subject = {
+      reasoning: snapshot.liveReasoning ?? snapshot.lastReasoning ?? '',
+      text: snapshot.lastAssistantText ?? '',
+      hasReasoning: hasLive || (snapshot.lastReasoning ?? '') !== '',
+    }
+
+    const now = Date.now()
+    const rulesState = entry.cot
+    let engaged = false
+    rules.forEach((rule, index) => {
+      if (engaged) return
+      const key = String(index) + ':' + rule.match + ':' + rule.field + ':' + rule.value
+      const st = rulesState.rules[key] ?? { hits: 0, lastFiredAt: null, lastMatch: false }
+
+      // not-contains 作用在 reasoning 且本就没有推理时：不算命中。
+      if (rule.field === 'reasoning' && rule.match === 'not-contains' && !subject.hasReasoning) {
+        st.lastMatch = false
+        st.hits = 0
+        return
+      }
+
+      let hit: boolean
+      if (rule.field === 'reasoning') {
+        hit = rule.match === 'contains' ? subject.reasoning.includes(rule.value) : !subject.reasoning.includes(rule.value)
+      } else if (rule.field === 'text') {
+        hit = rule.match === 'contains' ? subject.text.includes(rule.value) : !subject.text.includes(rule.value)
+      } else { // 'both'
+        const reasonHas = subject.reasoning.includes(rule.value)
+        const textHas = subject.text.includes(rule.value)
+        hit = rule.match === 'contains' ? (reasonHas || textHas) : (!reasonHas && !textHas)
+      }
+
+      st.lastMatch = hit
+      st.hits = hit ? st.hits + 1 : 0
+      this.log(entry, 'CoT rule ' + key + ' hit=' + String(hit) + ' hits=' + String(st.hits) + '/' + String(minHits))
+
+      const shouldFire = hit && st.hits >= minHits
+      if (!shouldFire) return
+      // 冷却：同一规则在冷却窗口内不重复触发（除非匹配状态先复位再命中）。
+      const coolMs = Math.max(entry.config.intervalMs, 5000) * 2
+      if (st.lastFiredAt !== null && now - st.lastFiredAt < coolMs) return
+
+      st.lastFiredAt = now
+      if (rule.action === 'cancel') {
+        const reason = 'reasoning-rule:' + rule.value
+        cancelLiveSession(this.ctx, sessionId, false, reason)
+        entry.lastAction = 'cot-cancel'
+        entry.lastActionAt = Date.now()
+        entry.lastNote = '思维链规则触发 cancel: ' + rule.value
+        entry.stuckCount = 0
+        this.log(entry, 'COT-CANCEL session=' + sessionId + ' rule=' + key + ' value=' + rule.value)
+      } else {
+        const steer = rule.message !== undefined && rule.message.trim() !== ''
+          ? rule.message.trim()
+          : '监控判定：思维链/回复匹配规则「' + rule.value + '」，请据此调整方向并继续推进任务。'
+        sendLiveMessage(this.ctx, sessionId, steer, 'steer')
+        entry.lastAction = 'cot-steer'
+        entry.lastActionAt = Date.now()
+        entry.lastNote = '思维链规则触发 steer: ' + rule.value
+        entry.stuckCount = 0
+        this.log(entry, 'COT-STEER session=' + sessionId + ' rule=' + key + ' steer=' + steer)
+      }
+      engaged = true
+      st.hits = 0
+    })
+    return engaged
+  }
+
   private hasLlm(): boolean {
     const ctx = this.ctx as unknown as { llm?: LlmService }
     return ctx.llm !== undefined