@roaming-ai/dsh-group-chat 0.2.1 → 0.3.0

package/src/core/types.ts

@@ -41,6 +41,23 @@ export interface GroupRecord {
   sessionIds: string[]
 }
 
+/** 会话约束条目类型（窗口外结论/约束备忘）。 */
+export type ConstraintKind = 'decided' | 'rejected' | 'open'
+
+/** 全部合法约束类型。 */
+export const CONSTRAINT_KINDS: readonly ConstraintKind[] = ['decided', 'rejected', 'open']
+
+/** 合法 kind 原样，其余 undefined。 */
+export function asConstraintKind(value: unknown): ConstraintKind | undefined {
+  return typeof value === 'string' && (CONSTRAINT_KINDS as readonly string[]).includes(value) ? value as ConstraintKind : undefined
+}
+
+/** 一条无主结论/约束（已定 / 否决 / 未决）。 */
+export interface SessionConstraint {
+  kind: ConstraintKind
+  text: string
+}
+
 /** 会话：消息挂在会话上。 */
 export interface SessionRecord {
   id: string
@@ -51,6 +68,10 @@ export interface SessionRecord {
   namePinned?: boolean
   /** 主题已被手动编辑：自动整理永久跳过（隐式固定）。 */
   topicPinned?: boolean
+  /** 窗口外结论/约束备忘；空则省略。 */
+  constraints?: SessionConstraint[]
+  /** 已折入备忘的最大消息 seq；0/缺省 = 尚未折过。 */
+  constraintsUpToSeq?: number
   messageIds: string[]
   createdAt: number
 }
@@ -91,6 +112,8 @@ export interface MessageRecord {
   thinkingSummary?: string
   model?: string
   error?: boolean
+  /** 发言失败时的角色 id；刷新后仍可对该条点重试。角色消息 speaker 即角色 id，此字段冗余兼容旧系统错误行。 */
+  failedRoleId?: string
   toolCalls?: ToolCallRecord[]
   ts: number
 }
@@ -129,6 +152,8 @@ export interface RunState {
   childProc: import('node:child_process').ChildProcess | null
   /** 最近一次 run 的结束标记：会话列表「已完成/已出错」状态的数据源。 */
   finished: RunFinished | null
+  /** 原地重试时被覆盖的失败消息 id；普通 send 为 null。 */
+  replaceMessageId: string | null
 }
 
 /** 角色发言的引擎产物。 */
@@ -180,12 +205,12 @@ export interface FileSearchResult {
 /** 发到客户端的全量快照（wire 形态）。 */
 export interface Snapshot {
   revision: number
-  run: { running: boolean, sessionId: string | null, currentRoleId: string | null, partial: string, partialReasoning: string, pendingConfirm: PendingConfirm | null, finished: RunFinished | null }
+  run: { running: boolean, sessionId: string | null, currentRoleId: string | null, partial: string, partialReasoning: string, pendingConfirm: PendingConfirm | null, finished: RunFinished | null, replaceMessageId: string | null }
   lastCreated: LastCreated | null
   groups: { id: string, name: string, workspaceDir: string, permissionTier: PermissionTier, roleIds: string[], sessionIds: string[] }[]
-  sessions: { id: string, groupId: string, name: string, topic: string, messageIds: string[], createdAt: number }[]
+  sessions: { id: string, groupId: string, name: string, topic: string, constraints?: SessionConstraint[], messageIds: string[], createdAt: number }[]
   roles: { id: string, groupId: string, name: string, color?: string, persona: string, provider: string, model: string, temperature?: number, reasoningEffort?: string, enabled: boolean, thinking: boolean }[]
-  messages: { id: string, sessionId: string, seq: number, speaker: string, text: string, reasoning?: string, model?: string, error?: boolean, toolCalls?: ToolCallRecord[], ts: number }[]
+  messages: { id: string, sessionId: string, seq: number, speaker: string, text: string, reasoning?: string, model?: string, error?: boolean, failedRoleId?: string, toolCalls?: ToolCallRecord[], ts: number }[]
   error?: string
 }
 

package/src/host/api/actions.ts

@@ -1,10 +1,11 @@
 /**
  * 动作分发（handleAction，POST /api/group-chat/action 的载荷）：
- * mutate（12 种 CRUD/配置操作）| send | stop | confirmCommand | models | efforts。
+ * mutate（12 种 CRUD/配置操作）| send | retrySpeak | stop | confirmCommand | models | efforts。
  * @module dsh-group-chat/host/api/actions
  */
 
 import { rmSync, unlinkSync } from 'node:fs'
+import { isSpeakFailure, repairFailedMessage } from '../../core/errors.ts'
 import type { BrowseResult, EffortOptions, GroupRecord, ModelCatalog, MutateArgs, RoleRecord, SendArgs, Snapshot } from '../../core/types.ts'
 import { asEffort, asNumber, asPermissionTier } from '../../core/types.ts'
 import { PALETTE } from '../state.ts'
@@ -210,6 +211,8 @@ export function createActions(core: HostState, deps: {
         if (run.running && run.sessionId === sess.id) return { ...snapshot(), error: '对话进行中，无法清空' }
         for (const mid of sess.messageIds) messages.delete(mid)
         sess.messageIds = []
+        sess.constraints = undefined
+        sess.constraintsUpToSeq = undefined
         schedulePersist({ session: sess.id })
         touch()
       }
@@ -243,11 +246,41 @@ export function createActions(core: HostState, deps: {
     run.queue = queue
     run.stopping = false
     run.finished = null // 新 run 覆盖旧的「输出完毕」未读标记
+    run.replaceMessageId = null
     touch()
     void runLoop(sess).catch((e) => console.error('group-chat run failed', e))
     return { ok: true }
   }
 
+  /** 对失败卡原地重试：只让该角色再讲一次，成功后覆盖同一条消息。 */
+  const retrySpeak = (args: { sessionId?: string, messageId?: string }): { ok: boolean, error?: string } => {
+    const sess = sessions.get(String(args && args.sessionId || ''))
+    if (!sess) return { ok: false, error: '会话不存在' }
+    if (run.running) return { ok: false, error: '已有对话进行中，请先停止' }
+    const msg = messages.get(String(args && args.messageId || ''))
+    if (!msg || msg.sessionId !== sess.id || !isSpeakFailure(msg)) return { ok: false, error: '没有可重试的失败发言' }
+    const g = groups.get(sess.groupId)
+    if (!g) return { ok: false, error: '群组不存在' }
+    const groupRoles = g.roleIds.map((id) => roles.get(id)).filter((r): r is RoleRecord => Boolean(r))
+    if (repairFailedMessage(msg, groupRoles)) {
+      schedulePersist({ session: sess.id })
+      touch()
+    }
+    const roleId = msg.failedRoleId || (msg.speaker !== 'user' && msg.speaker !== 'system' ? msg.speaker : '')
+    const role = roleId ? roles.get(roleId) : undefined
+    if (!role || role.groupId !== sess.groupId) return { ok: false, error: '失败角色已不存在，无法重试' }
+    if (!role.enabled) return { ok: false, error: '该角色已停用，无法重试' }
+    run.running = true
+    run.sessionId = sess.id
+    run.queue = [role.id]
+    run.stopping = false
+    run.finished = null
+    run.replaceMessageId = msg.id
+    touch()
+    void runLoop(sess, { replaceMessageId: msg.id }).catch((e) => console.error('group-chat retry failed', e))
+    return { ok: true }
+  }
+
   const stop = (args: { sessionId?: string }): { ok: boolean } => {
     if (run.running && (!args || !args.sessionId || run.sessionId === args.sessionId)) {
       run.stopping = true
@@ -322,6 +355,7 @@ export function createActions(core: HostState, deps: {
     const kind = body && body.kind
     if (kind === 'mutate') return { ok: true, snapshot: mutate(body as unknown as MutateArgs), lastCreated: core.lastCreated }
     if (kind === 'send') return send(body as unknown as SendArgs)
+    if (kind === 'retrySpeak') return retrySpeak(body as { sessionId?: string, messageId?: string })
     if (kind === 'stop') return stop(body as { sessionId?: string })
     if (kind === 'confirmCommand') return confirmCommand(body as { toolCallId?: string, allow?: boolean })
     if (kind === 'models') return { ok: true, ...(await models()) }

package/src/host/broadcast.ts

@@ -41,12 +41,12 @@ export function createBroadcast(core: HostState): Broadcast {
 
   const snapshot = (): Snapshot => ({
     revision: core.revision,
-    run: { running: core.run.running, sessionId: core.run.sessionId, currentRoleId: core.run.currentRoleId, partial: core.run.partial, partialReasoning: core.run.partialReasoning, pendingConfirm: core.run.pendingConfirm, finished: core.run.finished },
+    run: { running: core.run.running, sessionId: core.run.sessionId, currentRoleId: core.run.currentRoleId, partial: core.run.partial, partialReasoning: core.run.partialReasoning, pendingConfirm: core.run.pendingConfirm, finished: core.run.finished, replaceMessageId: core.run.replaceMessageId },
     lastCreated: core.lastCreated,
     groups: [...core.groups.values()].map((g) => ({ id: g.id, name: g.name, workspaceDir: g.workspaceDir, permissionTier: g.permissionTier, roleIds: g.roleIds.slice(), sessionIds: g.sessionIds.slice() })),
-    sessions: [...core.sessions.values()].map((s) => ({ id: s.id, groupId: s.groupId, name: s.name, topic: s.topic, messageIds: s.messageIds.slice(), createdAt: s.createdAt })),
+    sessions: [...core.sessions.values()].map((s) => ({ id: s.id, groupId: s.groupId, name: s.name, topic: s.topic, ...(s.constraints && s.constraints.length ? { constraints: s.constraints } : {}), messageIds: s.messageIds.slice(), createdAt: s.createdAt })),
     roles: [...core.roles.values()].map((r) => ({ id: r.id, groupId: r.groupId, name: r.name, color: r.color, persona: r.persona, provider: r.provider, model: r.model, temperature: r.temperature, reasoningEffort: r.reasoningEffort, enabled: r.enabled, thinking: r.thinking === true })),
-    messages: [...core.messages.values()].map((m) => ({ id: m.id, sessionId: m.sessionId, seq: m.seq, speaker: m.speaker, text: m.text, reasoning: m.reasoning, model: m.model, error: m.error, toolCalls: m.toolCalls, ts: m.ts })),
+    messages: [...core.messages.values()].map((m) => ({ id: m.id, sessionId: m.sessionId, seq: m.seq, speaker: m.speaker, text: m.text, reasoning: m.reasoning, model: m.model, error: m.error, failedRoleId: m.failedRoleId, toolCalls: m.toolCalls, ts: m.ts })),
   })
 
   return {

package/src/host/engine/conversation.ts

@@ -1,15 +1,18 @@
 /**
  * 对话引擎：消息追加、群聊记录转写、角色发言（speak：prompt 构建 + 流式
- * 轮次 + 工具回注循环）、多轮 runLoop（每轮结束触发 retitle 标题整理）。
+ * 轮次 + 工具回注循环）、多轮 runLoop（结束时后台 retitle + 窗口外约束折叠）。
  * @module dsh-group-chat/host/engine/conversation
  */
 
 import { realpathSync } from 'node:fs'
 import type { GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
+import { constraintBlock, formatTranscriptLine, prefixIds, speakerLabel, squeezedMessages, tempTranscript, WINDOW_SIZE } from '../../core/constraints.ts'
+import { unwrapSpeakFailure } from '../../core/errors.ts'
 import { TOOL_FLOOR_COST_CHARS, TOOL_REPEAT_LIMIT, TOOL_RESULTS_TOTAL_MAX, TRANSCRIPT_TOOL_SUMMARY } from '../../core/tools.ts'
 import type { GroupRecord, MessageRecord, RoleRecord, SessionRecord, SpeakResult, ToolCallRecord } from '../../core/types.ts'
 import { asEffort } from '../../core/types.ts'
 import type { HostState } from '../state.ts'
+import { createFold } from './fold.ts'
 import { createRetitle } from './retitle.ts'
 import type { Materials } from '../materials/index.ts'
 import type { Tools } from '../tools/index.ts'
@@ -30,16 +33,18 @@ interface StreamRound {
 export interface Conversation {
   /** 追加一条消息到会话（touch + 落盘调度）。 */
   appendMessage: (sess: SessionRecord, speaker: string, text: string, extra?: Partial<MessageRecord>) => MessageRecord
-  /** 多轮 round-robin 主循环（send 触发；finally 复位 run）。 */
-  runLoop: (sess: SessionRecord) => Promise<void>
+  /** 多轮 round-robin 主循环（send / retrySpeak 触发；finally 复位 run）。 */
+  runLoop: (sess: SessionRecord, opts?: { replaceMessageId?: string }) => Promise<void>
 }
 
 /** 创建对话引擎。 */
 export function createConversation(core: HostState, deps: { touch: () => void, schedulePersist: (targets?: { session?: string | null }) => void, materials: Materials, tools: Tools }): Conversation {
   const { llm, groups, roles, messages, run } = core
   const { touch, schedulePersist, materials, tools } = deps
-  // 标题/主题自动整理（独立关注点，见 retitle.ts；runLoop 每轮结束触发）
+  // 标题/主题自动整理 + 窗口外约束折叠（finally 之后并列后台跑，不占用 run）
   const retitle = createRetitle(core, { touch, schedulePersist })
+  const fold = createFold(core, { touch, schedulePersist })
+  const nameOf = (speaker: string): string => speakerLabel(speaker, (roles.get(speaker) || { name: undefined }).name)
 
   const appendMessage = (sess: SessionRecord, speaker: string, text: string, extra?: Partial<MessageRecord>): MessageRecord => {
     const msg: MessageRecord = { id: core.nid('msg'), sessionId: sess.id, seq: sess.messageIds.length + 1, speaker, text, reasoning: undefined, model: undefined, error: undefined, ts: Date.now() }
@@ -49,6 +54,7 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       if (extra.thinkingSummary !== undefined) msg.thinkingSummary = extra.thinkingSummary
       if (extra.model !== undefined) msg.model = extra.model
       if (extra.error !== undefined) msg.error = extra.error
+      if (extra.failedRoleId !== undefined) msg.failedRoleId = extra.failedRoleId
       if (Array.isArray(extra.toolCalls) && extra.toolCalls.length > 0) msg.toolCalls = extra.toolCalls
     }
     messages.set(msg.id, msg)
@@ -58,38 +64,75 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
     return msg
   }
 
-  /** 群聊记录 → 角色上下文块（最近 40 条、逐条 8k 截断、工具行压缩）。 */
-  const transcriptBlock = (sess: SessionRecord): string => {
+  /** 把失败回合写成该角色的消息（speaker = 角色 id），不再用系统胶囊顶替。 */
+  const writeFailure = (sess: SessionRecord, role: RoleRecord, err: unknown, replaceId?: string): void => {
+    const raw = unwrapSpeakFailure(String((err && (err as Error).message) || err))
+    const extra: Partial<MessageRecord> = {
+      error: true,
+      failedRoleId: role.id,
+      model: role.provider + ' / ' + role.model,
+    }
+    if (replaceId) {
+      const existing = messages.get(replaceId)
+      if (existing && existing.sessionId === sess.id) {
+        existing.speaker = role.id
+        existing.text = raw
+        existing.error = true
+        existing.failedRoleId = role.id
+        existing.model = extra.model
+        existing.reasoning = undefined
+        existing.reasoningFull = undefined
+        existing.thinkingSummary = undefined
+        existing.toolCalls = undefined
+        existing.ts = Date.now()
+        touch()
+        schedulePersist({ session: sess.id })
+        return
+      }
+    }
+    appendMessage(sess, role.id, raw, extra)
+  }
+
+  /** 成功发言写入：replaceId 存在则原地覆盖失败卡。 */
+  const writeSuccess = (sess: SessionRecord, role: RoleRecord, out: SpeakResult, replaceId?: string): void => {
+    const extra: Partial<MessageRecord> = { model: role.provider + ' / ' + role.model, reasoning: out.reasoning, toolCalls: out.toolCalls }
+    if (replaceId) {
+      const existing = messages.get(replaceId)
+      if (existing && existing.sessionId === sess.id) {
+        existing.speaker = role.id
+        existing.text = out.text
+        existing.error = undefined
+        existing.failedRoleId = undefined
+        existing.model = extra.model
+        existing.reasoning = out.reasoning
+        existing.reasoningFull = undefined
+        existing.thinkingSummary = undefined
+        existing.toolCalls = Array.isArray(out.toolCalls) && out.toolCalls.length > 0 ? out.toolCalls : undefined
+        existing.ts = Date.now()
+        touch()
+        schedulePersist({ session: sess.id })
+        return
+      }
+    }
+    appendMessage(sess, role.id, out.text, extra)
+  }
+
+  /** 群聊记录 → 角色上下文块（最近 40 条 + 未折入临时原文）。失败卡不进上下文。重试截到该条之前。 */
+  const transcriptBlock = (sess: SessionRecord, skipId?: string): string => {
     const out: string[] = []
-    for (const mid of sess.messageIds) {
+    for (const mid of prefixIds(sess.messageIds, skipId).slice(-WINDOW_SIZE)) {
       const m = messages.get(mid)
-      if (!m) continue
-      const name = m.speaker === 'user' ? '用户' : m.speaker === 'system' ? '系统' : (roles.get(m.speaker) || { name: undefined }).name || '成员'
-      let text = m.text || ''
-      if (text.length > 8000) text = text.slice(0, 8000) + '…(已截断)'
-      let line = '【' + name + '】' + text
-      if (Array.isArray(m.toolCalls)) {
-        for (const c of m.toolCalls) {
-          if (!c || typeof c.tool !== 'string') continue
-          let brief = ''
-          try {
-            brief = JSON.stringify(c.args) || ''
-          } catch {
-            brief = ''
-          }
-          if (brief.length > 60) brief = brief.slice(0, 60) + '…'
-          const st = c.status === 'ok' ? '成功' : c.status === 'denied' ? '用户拒绝' : '失败'
-          let ob = String(c.output || '')
-          if (ob.length > TRANSCRIPT_TOOL_SUMMARY) ob = ob.slice(0, TRANSCRIPT_TOOL_SUMMARY) + '…'
-          line += '\n  [工具] ' + c.tool + ' ' + brief + ' → ' + st + (ob ? '（' + ob.replace(/\s+/g, ' ') + '）' : '')
-        }
-      }
-      out.push(line)
+      if (!m || m.id === skipId || m.error) continue
+      out.push(formatTranscriptLine(m, nameOf(m.speaker)))
     }
-    return out.slice(-40).join('\n\n')
+    const live = out.join('\n\n')
+    const temp = tempTranscript(squeezedMessages(messages, sess, skipId), (m) => nameOf(m.speaker))
+    if (!temp) return live
+    if (!live) return temp
+    return temp + '\n\n' + live
   }
 
-  const speak = async (g: GroupRecord, sess: SessionRecord, role: RoleRecord): Promise<SpeakResult> => {
+  const speak = async (g: GroupRecord, sess: SessionRecord, role: RoleRecord, skipId?: string): Promise<SpeakResult> => {
     const ws = await materials.loadWorkspaceFiles(g)
     const parts = ws.parts
     const sys = [
@@ -99,6 +142,7 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       '- 名称：' + role.name,
       '- 人设：' + (role.persona ? role.persona : '（未填写，请以积极协作者的身份参与讨论）'),
       sess.topic ? '\n# 本会话主题\n' + sess.topic : '',
+      constraintBlock(sess.constraints),
       materials.materialBlock(parts, ws.dir),
       ws.dir
         ? '\n# 可用工具\n你可以调用工具在群组工作区目录（' + ws.dir + '）内查看文件与目录' +
@@ -115,7 +159,7 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       '- 保持简洁，通常不超过 300 字',
     ].filter((s) => s !== '').join('\n')
 
-    const history = transcriptBlock(sess)
+    const history = transcriptBlock(sess, skipId)
     const intro = history
       ? '以下是本会话的群聊记录（从旧到新）：\n\n' + history
       : '本会话刚刚开始，请围绕主题做简短开场发言。'
@@ -281,10 +325,12 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
     return { text: texts.join('\n\n').trim(), reasoning: reasonings.join('\n\n').trim() || undefined, toolCalls }
   }
 
-  const runLoop = async (sess: SessionRecord): Promise<void> => {
+  const runLoop = async (sess: SessionRecord, opts?: { replaceMessageId?: string }): Promise<void> => {
     const g = groups.get(sess.groupId)
     const startCount = sess.messageIds.length
     let failed = false // 发言失败 → 会话列表「已出错」标记
+    let replaceId = opts && opts.replaceMessageId
+    run.replaceMessageId = replaceId || null
     try {
       while (run.queue.length > 0 && !run.stopping) {
         const roleId = run.queue.shift()!
@@ -294,15 +340,30 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
         run.partialReasoning = ''
         touch()
         if (!role) continue
+        const targetId = replaceId
+        replaceId = undefined
         try {
-          const out = await speak(g!, sess, role)
+          const out = await speak(g!, sess, role, targetId)
           // 停止后不落部分消息（已有「已停止本次对话」系统消息承接）
           if (!run.stopping && (out.text || (Array.isArray(out.toolCalls) && out.toolCalls.length > 0))) {
-            appendMessage(sess, role.id, out.text, { model: role.provider + ' / ' + role.model, reasoning: out.reasoning, toolCalls: out.toolCalls })
+            writeSuccess(sess, role, out, targetId)
+          } else if (!run.stopping && targetId) {
+            // 重试得到空输出：保留失败卡，避免成功覆盖成空白气泡
+            failed = true
+            run.currentRoleId = null
+            run.partial = ''
+            run.partialReasoning = ''
+            run.replaceMessageId = null
+            writeFailure(sess, role, '模型没有返回内容', targetId)
+            break
           }
         } catch (e) {
           failed = true
-          appendMessage(sess, 'system', '角色「' + role.name + '」发言失败：' + String((e && (e as Error).message) || e), { error: true })
+          run.currentRoleId = null
+          run.partial = ''
+          run.partialReasoning = ''
+          run.replaceMessageId = null
+          writeFailure(sess, role, e, targetId)
           break
         }
       }
@@ -321,10 +382,14 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       run.confirmSignal = null
       run.childProc = null
       run.stopping = false
+      run.replaceMessageId = null
       touch()
     }
-    // 本轮有新消息落盘 → 后台整理标题/主题（fire-and-forget，不产生消息、静默失败）
-    if (sess.messageIds.length > startCount) void retitle(sess)
+    // 本轮有新消息落盘，或原地重试覆盖了失败卡 → 后台整理标题/主题 + 窗口外约束
+    if (sess.messageIds.length > startCount || (opts && opts.replaceMessageId)) {
+      void retitle(sess)
+      void fold(sess)
+    }
   }
 
   return { appendMessage, runLoop }

package/src/host/engine/fold.ts

@@ -0,0 +1,114 @@
+/**
+ * 窗口外结论/约束备忘：整次 runLoop 结束后后台折叠（仿 retitle）。
+ * 立刻 idle；未折完用水位 + 临时原文表达。v1 复用 purpose session-title 关思考。
+ * @module dsh-group-chat/host/engine/fold
+ */
+
+import type { GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
+import {
+  CONSTRAINT_MAX_CHARS,
+  CONSTRAINT_MAX_ITEMS,
+  KIND_LABEL,
+  downgradeWithoutUser,
+  parseConstraints,
+  squeezedMaxSeq,
+  squeezedMessages,
+  speakerLabel,
+  takeFoldBatch,
+} from '../../core/constraints.ts'
+import type { SessionRecord } from '../../core/types.ts'
+import type { HostState } from '../state.ts'
+
+/** DSH 默认模型（与 retitle 同一读取面；缺位返回 null）。 */
+const defaultModel = (core: HostState): { provider: string, model: string } | null => {
+  try {
+    const svc = core.ctx.reflect.get('agentDefaultModel')
+    const sel = svc ? svc.currentSelection() : null
+    return sel && typeof sel.provider === 'string' && typeof sel.model === 'string' && sel.provider && sel.model
+      ? { provider: sel.provider, model: sel.model }
+      : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 每轮 send 结束后折叠窗口外约束：fire-and-forget、不产生消息、静默失败。
+ * 同会话去重；会话已清空则 abort。内存 {constraints, constraintsUpToSeq} 一次挂上。
+ */
+export function createFold(core: HostState, deps: { touch: () => void, schedulePersist: (targets?: { session?: string | null }) => void }): (sess: SessionRecord) => Promise<void> {
+  const { llm, messages, roles } = core
+  const { touch, schedulePersist } = deps
+  const folding = new Set<string>()
+
+  const nameOf = (speaker: string): string => speakerLabel(speaker, (roles.get(speaker) || { name: undefined }).name)
+
+  return async (sess: SessionRecord): Promise<void> => {
+    if (folding.has(sess.id)) return
+    const squeezed = squeezedMessages(messages, sess)
+    if (!squeezed.length) return
+    const input = takeFoldBatch(squeezed, (m) => nameOf(m.speaker))
+    const watermark = squeezedMaxSeq(input.consumed)
+    if (watermark <= 0) return
+
+    const commit = (next: SessionRecord['constraints'] | undefined): void => {
+      const live = core.sessions.get(sess.id)
+      if (!live || live.messageIds.length === 0) return
+      if (next && next.length) live.constraints = next
+      live.constraintsUpToSeq = watermark
+      schedulePersist({ session: live.id })
+      touch()
+    }
+
+    if (input.allSystem) {
+      commit(undefined)
+      return
+    }
+
+    const dm = defaultModel(core)
+    if (!dm) return
+
+    folding.add(sess.id)
+    try {
+      const existing = (sess.constraints || []).map((c) => '- ' + KIND_LABEL[c.kind] + '：' + c.text)
+      const sys = [
+        '你是群聊会话的约束整理助手。把已经离开最近对话窗口的旧消息压成无主结论/约束备忘。',
+        '',
+        '# 规则',
+        '- 只输出一行 JSON：{"constraints":[{"kind":"decided|rejected|open","text":"…"}, ...]}',
+        '- kind 只能是 decided（已定）/ rejected（否决）/ open（未决）',
+        '- 无主：条目不写说话人。8–12 条、合计不超过 ' + CONSTRAINT_MAX_CHARS + ' 字，最多 ' + CONSTRAINT_MAX_ITEMS + ' 条',
+        '- 已定/否决只能依据【用户】原文；角色对打一律标 open（未决）',
+        '- 同主题：新已定覆盖旧未决；旧已定不能因角色反对改写，除非【用户】改口',
+        '- 没有新结论时输出 {"constraints":[]}（保留旧备忘）',
+        '- 超预算时按 已定 > 未决 > 过程叙述 取舍；语言跟随记录',
+        '',
+        '当前备忘：',
+        existing.length ? existing.join('\n') : '（空）',
+      ].join('\n')
+      const user = '旧消息（从旧到新，含工具一行摘要）：\n\n' + input.lines.join('\n\n')
+      let acc = ''
+      for await (const chunk of llm.stream({
+        provider: dm.provider,
+        model: dm.model,
+        system: sys,
+        purpose: 'session-title',
+        messages: [{ id: ('g' + core.revision + '-c0') as Message['id'], role: 'user', content: [{ type: 'text', text: user }], source: { kind: 'user' } }],
+      } as GenerateOptions)) {
+        if (chunk.type === 'text-delta') {
+          acc += chunk.text
+          if (acc.length > 4000) break
+        } else if (chunk.type === 'finish') {
+          break
+        }
+      }
+      const parsed = parseConstraints(acc)
+      if (parsed === null) return
+      commit(parsed.length ? downgradeWithoutUser(parsed, input.hasUser) : undefined)
+    } catch (e) {
+      console.error('[dsh-group-chat] 会话约束折叠失败（跳过，不影响对话）：', e)
+    } finally {
+      folding.delete(sess.id)
+    }
+  }
+}

package/src/host/engine/index.ts

@@ -5,4 +5,5 @@
 
 export { createConversation } from './conversation.ts'
 export type { Conversation } from './conversation.ts'
+export { createFold } from './fold.ts'
 export { createRetitle } from './retitle.ts'

package/src/host/engine/retitle.ts

@@ -1,13 +1,17 @@
 /**
  * 会话标题/主题自动整理（参照 oil-codex-title）：每轮结束后用 DSH 默认模型
- * 后台生成「类别 emoji + 对象｜目标」名称与演进式主题；手动编辑过的字段
+ * 后台生成。名称只在仍为默认占位时写一次；主题每轮演进。手动编辑过的字段
  * 永久跳过（隐式固定）。
  * @module dsh-group-chat/host/engine/retitle
  */
 
 import type { GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
 import type { SessionRecord } from '../../core/types.ts'
-import type { HostState } from '../state.ts'
+import { DEFAULT_SESSION_NAME, type HostState } from '../state.ts'
+
+/** 仍是新建占位名（含改名之前的「会话 N」存量），自动标题尚未落地。 */
+const isPlaceholderName = (name: string): boolean =>
+  name === DEFAULT_SESSION_NAME || /^会话 \d+$/.test(name)
 
 /** DSH 默认模型（agentDefaultModel 服务缺位或未配置时返回 null，调用方静默跳过）。 */
 const defaultModel = (core: HostState): { provider: string, model: string } | null => {
@@ -30,7 +34,7 @@ const titleTranscript = (core: HostState, sess: SessionRecord): string => {
   const out: string[] = []
   for (const mid of sess.messageIds.slice(-40)) {
     const m = core.messages.get(mid)
-    if (!m || m.speaker === 'system' || !m.text) continue
+    if (!m || m.speaker === 'system' || m.error || !m.text) continue
     const name = m.speaker === 'user' ? '用户' : (core.roles.get(m.speaker) || { name: undefined }).name || '成员'
     out.push('【' + name + '】' + m.text.replace(/\s+/g, ' ').slice(0, 500))
   }
@@ -55,9 +59,9 @@ const parseRetitle = (raw: string): { name?: string, topic?: string } => {
 
 /**
  * 每轮结束后根据聊天内容整理会话名称与主题：后台 fire-and-forget、不产生
- * 消息、静默失败。名称 =「类别 emoji + 对象｜目标」（类别固定、对象稳定、
- * 目标实质变化才改）；主题 = 演进式一句话摘要（对象+目标+当前焦点），注入
- * 后续轮次的角色上下文。手动编辑过的字段永久跳过（隐式固定，apply 时复查）。
+ * 消息、静默失败。名称只在仍为默认占位时生成一次（「类别 emoji + 对象｜目标」）；
+ * 主题 = 演进式一句话摘要（对象+目标+当前焦点），每轮更新，注入后续角色上下文。
+ * 手动编辑过的字段永久跳过（隐式固定，apply 时复查）。
  */
 export function createRetitle(core: HostState, deps: { touch: () => void, schedulePersist: (targets?: { session?: string | null }) => void }): (sess: SessionRecord) => Promise<void> {
   const { llm } = core
@@ -69,7 +73,8 @@ export function createRetitle(core: HostState, deps: { touch: () => void, schedu
   return async (sess: SessionRecord): Promise<void> => {
     if (retitling.has(sess.id)) return
     const dm = defaultModel(core)
-    if (!dm || (sess.namePinned && sess.topicPinned)) return
+    const nameFrozen = !!sess.namePinned || !isPlaceholderName(sess.name)
+    if (!dm || (nameFrozen && sess.topicPinned)) return
     const transcript = titleTranscript(core, sess)
     if (!transcript) return
     retitling.add(sess.id)
@@ -80,9 +85,9 @@ export function createRetitle(core: HostState, deps: { touch: () => void, schedu
         '# 名称规则',
         '- 格式：「类别 emoji + 对象｜目标」，例如「🔎 缓存选型｜Redis 与本地 KV 对比」',
         '- 类别固定六选一：🔎 调研对比（多方案/多观点比较）、💡 头脑风暴（创意发散）、⚖️ 方案评审（评审已有方案或产物）、🛠️ 排查修复（定位与解决问题）、📝 方法整理（总结沉淀方法与知识）、🗣️ 通用讨论（其余兜底）',
-        '- 对象在前且稳定：把辨识度最高的讨论对象放最前；省略群组名（外层已展示）；除非讨论对象实质变化，沿用当前名称里的对象名；「继续」「追问」等不改变主线',
+        '- 对象在前：把辨识度最高的讨论对象放最前；省略群组名（外层已展示）',
         '- 目标 = 当前正在做的事，动宾短语，保持简洁',
-        '- 名称总长不超过 16 个字',
+        '- 名称总长不超过 16 个字；名称只生成一次，不要为了追问/继续而改名',
         '',
         '# 主题规则',
         '- 一句话演进式摘要：讨论对象 + 当前目标 + 当前焦点/分歧点',
@@ -92,7 +97,7 @@ export function createRetitle(core: HostState, deps: { touch: () => void, schedu
         '- 语言跟随用户消息的主要语言；保留产品名与技术名词',
         '- 只输出一行 JSON：{"name": "…", "topic": "…"}，不要输出其他内容',
         '',
-        '当前名称：' + (sess.namePinned ? '（已手动固定，本次不要输出 name 字段）' : sess.name),
+        '当前名称：' + (nameFrozen ? '（已固定，本次不要输出 name 字段）' : sess.name),
         '当前主题：' + (sess.topicPinned ? '（已手动固定，本次不要输出 topic 字段）' : (sess.topic || '（空）')),
       ].join('\n')
       let acc = ''
@@ -120,7 +125,7 @@ export function createRetitle(core: HostState, deps: { touch: () => void, schedu
       }
       const parsed = parseRetitle(acc)
       let changed = false
-      if (parsed.name && !sess.namePinned) { sess.name = parsed.name; changed = true }
+      if (parsed.name && !sess.namePinned && isPlaceholderName(sess.name)) { sess.name = parsed.name; changed = true }
       if (parsed.topic && !sess.topicPinned) { sess.topic = parsed.topic; changed = true }
       if (changed) {
         schedulePersist({ session: sess.id })