dsh-session-bridge 0.2.1 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-bridge",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "会话桥（dsh-session-bridge）：通过提示词创建新的主会话（顶层 UI 会话）、向任意会话发送消息、等待会话的下一条回复、读取会话消息，并按会话名或 id 跨工作区查找会话；此外支持监控/调度主任务与归档会话。",
   "private": false,
   "type": "module",
@@ -52,28 +52,28 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-workspace": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-workspace": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
     "cordis": "^4.0.0-rc.7"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-brand": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-scope": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-util-values": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
-    "@deepseek-ai/dsh-workspace": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-agent-presets": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-brand": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-scope": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-session-persistence": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-util-values": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
+    "@deepseek-ai/dsh-workspace": "^0.1.0-rc.6 || ^0.1.1-0 || ^0.1.2-0 || ^0.1.5-0",
     "@types/node": "^24.0.0",
     "cordis": "^4.0.0-rc.7",
     "tsdown": "^0.22.14",

package/src/core.ts

@@ -21,7 +21,9 @@ export interface LiveAgentLike {
   whenIdle?(): Promise<void>
   readonly ctx: Context
   readonly inbox?: {
-    hasPending: boolean
+    // dsh 0.1.2 及之前：`hasPending` getter；dsh 0.1.5 起已删除，仅有
+    // nextTurn / nextStep 只读数组（Inbox 成为 driver 持有的接口）。
+    hasPending?: boolean
     nextTurn?: readonly unknown[]
     nextStep?: readonly unknown[]
   }
@@ -86,6 +88,34 @@ export function asEventList(events: unknown): readonly SessionEvent[] {
   return Array.isArray(events) ? events : []
 }
 
+/**
+ * 读取一个持久化（离线）会话的事件日志与头部元数据。兼容两代 persistence API：
+ * - 旧版：`sessionPersistence.inspect(id)` 直接返回 { events, meta }；
+ * - dsh 0.1.5 之后：`inspect` 已删除，改用 `open(id, 'read')` → `handle.read()`
+ *   （+ `handle.header`），读句柄不抢写所有权，读后必须 close()。
+ * 会话不存在时两个 API 都抛错，调用方按原语义处理。
+ */
+export async function inspectPersistedSession(ctx: Context, id: string): Promise<{ events: readonly SessionEvent[]; meta: { cwd?: string } }> {
+  const persistence = ctx.sessionPersistence as unknown as {
+    inspect?: (sid: string) => Promise<{ events: readonly SessionEvent[]; meta: { cwd?: string } }>
+    open?: (sid: string, access: 'read') => Promise<{
+      header: { cwd?: string }
+      read(): Promise<{ events: readonly SessionEvent[] }>
+      close(): Promise<void>
+    }>
+  }
+  if (typeof persistence.inspect === 'function') {
+    return await persistence.inspect(id)
+  }
+  const handle = await persistence.open!(id, 'read')
+  try {
+    const { events } = await handle.read()
+    return { events, meta: handle.header }
+  } finally {
+    await handle.close()
+  }
+}
+
 /** agent.followup / steer 接受的用户消息值。 */
 export function userMessage(text: string): unknown {
   return {
@@ -108,6 +138,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
@@ -142,7 +185,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
@@ -156,6 +201,166 @@ 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 会话的事件日志折叠出其"最近推理/文本增量流"。兼容两代日志形状：
+ * - dsh 0.1.5 之后：turn 内不再发布独立 chunk 事件，流式增量内嵌在已定型
+ *   assistant/message（或未定型 assistant/attempt）事件的 `stream` 记录里
+ *   （reasoning-chunks / text-chunks 批量段 + 原始 chunk：reasoning-delta / text-delta）；
+ * - 0.1.2-rc 之前：独立的 assistant/chunk 事件（turn 中途即可见、增量，
+ *   这正是旧版监控思维链并按规则提前终止所需的粒度）。
+ * 两者兼读、取最新一份；无任何增量（会话空闲、或该 provider 不流式推理/无推理）
+ * 返回 null，调用方应回落为 foldMessages 里已定型的 message.reasoning。
+ * 纯读、无副作用；事件形状不做任何假设，缺失/异常一律安全处理。
+ */
+export function liveReasoningSnapshot(events: readonly SessionEvent[]): CoTLiveSlice | null {
+  const list = asEventList(events)
+  // 旧格式只累积"最近一条已定型 assistant/message 之后"的流式增量（in-flight 窗口）；
+  // 新格式的 stream 随定型事件落地，直接以最新携带 stream 的事件为准。
+  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) {
+    const type = event.type as string
+    if (type === 'assistant/message' || type === 'assistant/attempt') {
+      const data = event.data as { turn?: unknown; step?: unknown; stream?: unknown } | null | undefined
+      if (data !== null && data !== undefined && typeof data === 'object' && Array.isArray(data.stream)) {
+        let r = ''
+        let t = ''
+        for (const raw of data.stream as unknown[]) {
+          const record = raw as { type?: unknown; texts?: unknown; text?: unknown; chunk?: unknown } | null
+          if (record === null || typeof record !== 'object') continue
+          if (record.type === 'reasoning-chunks' && Array.isArray(record.texts)) {
+            for (const s of record.texts as unknown[]) if (typeof s === 'string') r += s
+          } else if (record.type === 'text-chunks' && Array.isArray(record.texts)) {
+            for (const s of record.texts as unknown[]) if (typeof s === 'string') t += s
+          } else if (record.type === 'chunk') {
+            const c = record.chunk as { type?: unknown; text?: unknown } | null
+            if (c !== null && typeof c === 'object' && typeof c.type === 'string' && typeof c.text === 'string') {
+              if (c.type === 'reasoning-delta') r += c.text
+              else if (c.type === 'text-delta') t += c.text
+            }
+          }
+        }
+        if (r !== '' || t !== '') {
+          if (typeof data.turn === 'number') turn = data.turn
+          if (typeof data.step === 'number') step = data.step
+          reasoning = r
+          text = t
+          seq = event.seq
+          time = event.time
+          foundDelta = true
+        }
+      }
+      if (type === 'assistant/message') lastFinalizedSeq = event.seq
+      continue
+    }
+    // 旧格式：独立 assistant/chunk 事件。
+    if (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 字符）。
@@ -203,6 +408,8 @@ export interface WaitForReplyOptions {
   timeoutMs: number
   signal?: AbortSignal
   requireTurnEnd?: boolean
+  /** true 时等待到 baseline 之后出现一个“新完成的输出段落”（assistant/message），立即返回该段，不等整个 turn。 */
+  waitForSegment?: boolean
 }
 
 /**
@@ -221,8 +428,10 @@ 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
@@ -232,22 +441,35 @@ export async function waitForReply(opts: WaitForReplyOptions): Promise<BridgeWai
       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,
   }
@@ -342,6 +564,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）。 */
@@ -369,13 +597,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 {
@@ -389,10 +622,14 @@ export function statusSnapshot(ctx: Context, agent: LiveAgentLike): BridgeStatus
     lastTurn,
     lastActivityAt,
     stalledMs: lastActivityAt === null ? null : Date.now() - lastActivityAt,
-    pendingWork: inbox?.hasPending ?? false,
+    // 双兼容：0.1.2 用 hasPending getter；0.1.5 起只有 nextTurn/nextStep 数组。
+    pendingWork: inbox?.hasPending === true || (inbox?.nextTurn?.length ?? 0) + (inbox?.nextStep?.length ?? 0) > 0,
     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