@roaming-ai/dsh-group-chat 0.2.2 → 0.3.1

package/src/host/engine/conversation.ts

@@ -1,15 +1,19 @@
 /**
  * 对话引擎：消息追加、群聊记录转写、角色发言（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, 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 { speakerNameOf } from './defaults.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 +34,17 @@ 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 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,68 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
     return msg
   }
 
-  /** 群聊记录 → 角色上下文块（最近 40 条、逐条 8k 截断、工具行压缩）。 */
-  const transcriptBlock = (sess: SessionRecord): string => {
+  /** 原地覆盖既有消息（重试槽位）；目标不存在或不属于本会话时返回 false，由调用方走追加。 */
+  const overwriteMessage = (sess: SessionRecord, replaceId: string | undefined, patch: Partial<MessageRecord>): boolean => {
+    if (!replaceId) return false
+    const existing = messages.get(replaceId)
+    if (!existing || existing.sessionId !== sess.id) return false
+    Object.assign(existing, patch, { ts: Date.now() })
+    touch()
+    schedulePersist({ session: sess.id })
+    return true
+  }
+
+  /** 把失败回合写成该角色的消息（speaker = 角色 id），不再用系统胶囊顶替。 */
+  const writeFailure = (sess: SessionRecord, role: RoleRecord, err: unknown, replaceId?: string): void => {
+    const raw = unwrapSpeakFailure(String((err && (err as Error).message) || err))
+    const model = role.provider + ' / ' + role.model
+    const extra: Partial<MessageRecord> = { error: true, failedRoleId: role.id, model }
+    if (overwriteMessage(sess, replaceId, {
+      speaker: role.id,
+      text: raw,
+      ...extra,
+      reasoning: undefined,
+      reasoningFull: undefined,
+      thinkingSummary: undefined,
+      toolCalls: undefined,
+    })) return
+    appendMessage(sess, role.id, raw, extra)
+  }
+
+  /** 成功发言写入：replaceId 存在则原地覆盖失败卡。 */
+  const writeSuccess = (sess: SessionRecord, role: RoleRecord, out: SpeakResult, replaceId?: string): void => {
+    const model = role.provider + ' / ' + role.model
+    const toolCalls = Array.isArray(out.toolCalls) && out.toolCalls.length > 0 ? out.toolCalls : undefined
+    if (overwriteMessage(sess, replaceId, {
+      speaker: role.id,
+      text: out.text,
+      error: undefined,
+      failedRoleId: undefined,
+      model,
+      reasoning: out.reasoning,
+      reasoningFull: undefined,
+      thinkingSummary: undefined,
+      toolCalls,
+    })) return
+    appendMessage(sess, role.id, out.text, { model, reasoning: out.reasoning, toolCalls: out.toolCalls })
+  }
+
+  /** 群聊记录 → 角色上下文块（最近 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, speakerNameOf(roles, m.speaker)))
     }
-    return out.slice(-40).join('\n\n')
+    const live = out.join('\n\n')
+    const temp = tempTranscript(squeezedMessages(messages, sess, skipId), (m) => speakerNameOf(roles, 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 +135,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 +152,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
       : '本会话刚刚开始，请围绕主题做简短开场发言。'
@@ -253,7 +290,10 @@ export function createConversation(core: HostState, deps: { touch: () => void, s
       msgs.push({ id: ('g' + core.revision + '-a' + msgs.length) as Message['id'], role: 'assistant', content: assistantContent, source: { kind: 'model', provider: role.provider, model: role.model } })
       for (const tc of round.tcs) {
         if (run.stopping) break
-        const res = await tools.executeTool(g, wsRoot!, tc)
+        // wsRoot 为 null 时 toolSchemas 必为空、不会产生 tool-call；防御性跳出，
+        // 不把空根传进沙箱
+        if (wsRoot === null) break
+        const res = await tools.executeTool(g, wsRoot, tc)
         const output = String(res.output || '')
         toolCalls.push({ tool: tc.name, args: res.args, status: res.status, output, durationMs: res.durationMs })
         budgetUsed += Math.max(output.length, TOOL_FLOOR_COST_CHARS)
@@ -281,11 +321,16 @@ 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 g = groups.get(sess.groupId)
+  const runLoop = async (sess: SessionRecord, opts?: { replaceMessageId?: string }): Promise<void> => {
+    const g = groups.get(sess.groupId) ?? null
     const startCount = sess.messageIds.length
     let failed = false // 发言失败 → 会话列表「已出错」标记
+    let replaceId = opts && opts.replaceMessageId
+    run.replaceMessageId = replaceId || null
     try {
+      // 群组在 run 期间不可删（send 已校验 + deleteGroup 拦截运行中群组）；
+      // 防御性早退——置空让 finally 走统一复位路径
+      if (!g) return
       while (run.queue.length > 0 && !run.stopping) {
         const roleId = run.queue.shift()!
         const role = roles.get(roleId)
@@ -294,15 +339,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 +381,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/defaults.ts

@@ -0,0 +1,28 @@
+/**
+ * 引擎共享小件：DSH 默认模型读取 + 发言人展示名（retitle / fold / conversation 共用）。
+ * @module dsh-group-chat/host/engine/defaults
+ */
+
+import { speakerLabel } from '../../core/constraints.ts'
+import type { RoleRecord } from '../../core/types.ts'
+import type { HostState } from '../state.ts'
+
+/** DSH 默认模型（agentDefaultModel 服务缺位或未配置时返回 null，调用方静默跳过）。 */
+export const defaultModel = (core: HostState): { provider: string, model: string } | null => {
+  try {
+    // cordis 语义：未 inject 的 ctx 属性访问会抛错（"cannot get property without
+    // inject"），`?.` 接不住——可选消费必须走 reflect.get（读全局注册表，缺位返回
+    // undefined）。直接属性访问曾致 retitle 被静默跳过（标题/主题从不生成）。
+    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
+  }
+}
+
+/** 发言人展示名（roles 表内查角色名；user/system 固定文案，见 speakerLabel）。 */
+export const speakerNameOf = (roles: Map<string, RoleRecord>, speaker: string): string =>
+  speakerLabel(speaker, roles.get(speaker)?.name)

package/src/host/engine/fold.ts

@@ -0,0 +1,99 @@
+/**
+ * 窗口外结论/约束备忘：整次 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,
+  takeFoldBatch,
+} from '../../core/constraints.ts'
+import type { SessionRecord } from '../../core/types.ts'
+import type { HostState } from '../state.ts'
+import { defaultModel, speakerNameOf } from './defaults.ts'
+
+/**
+ * 每轮 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>()
+
+  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) => speakerNameOf(roles, 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,63 +1,45 @@
 /**
  * 会话标题/主题自动整理（参照 oil-codex-title）：每轮结束后用 DSH 默认模型
- * 后台生成「类别 emoji + 对象｜目标」名称与演进式主题；手动编辑过的字段
+ * 后台生成。名称只在仍为默认占位时写一次；主题每轮演进。手动编辑过的字段
  * 永久跳过（隐式固定）。
  * @module dsh-group-chat/host/engine/retitle
  */
 
 import type { GenerateOptions, Message } from '@deepseek-ai/dsh-llm'
+import { looseJson } from '../../core/json.ts'
 import type { SessionRecord } from '../../core/types.ts'
-import type { HostState } from '../state.ts'
+import { DEFAULT_SESSION_NAME, type HostState } from '../state.ts'
+import { defaultModel, speakerNameOf } from './defaults.ts'
 
-/** DSH 默认模型（agentDefaultModel 服务缺位或未配置时返回 null，调用方静默跳过）。 */
-const defaultModel = (core: HostState): { provider: string, model: string } | null => {
-  try {
-    // cordis 语义：未 inject 的 ctx 属性访问会抛错（"cannot get property without
-    // inject"），`?.` 接不住——可选消费必须走 reflect.get（读全局注册表，缺位返回
-    // undefined）。直接属性访问曾致 retitle 被静默跳过（标题/主题从不生成）。
-    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
-  }
-}
+/** 仍是新建占位名（含改名之前的「会话 N」存量），自动标题尚未落地。 */
+const isPlaceholderName = (name: string): boolean =>
+  name === DEFAULT_SESSION_NAME || /^会话 \d+$/.test(name)
 
 /** 命名输入：最近 40 条非系统消息的紧凑转写（每条 500 字符封顶，命名不需要全文）。 */
 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
-    const name = m.speaker === 'user' ? '用户' : (core.roles.get(m.speaker) || { name: undefined }).name || '成员'
-    out.push('【' + name + '】' + m.text.replace(/\s+/g, ' ').slice(0, 500))
+    if (!m || m.speaker === 'system' || m.error || !m.text) continue
+    out.push('【' + speakerNameOf(core.roles, m.speaker) + '】' + m.text.replace(/\s+/g, ' ').slice(0, 500))
   }
   return out.join('\n')
 }
 
-/** 宽容解析模型输出：剥代码围栏 → 取首个 { 至末个 } 的 JSON → 校验并封顶字段。 */
+/** 宽容解析模型输出：剥代码围栏 → looseJson → 校验并封顶字段。 */
 const parseRetitle = (raw: string): { name?: string, topic?: string } => {
-  const body = raw.replace(/```(?:json)?/g, '')
-  const l = body.indexOf('{')
-  const r = body.lastIndexOf('}')
-  if (l < 0 || r <= l) return {}
-  try {
-    const o = JSON.parse(body.slice(l, r + 1)) as { name?: unknown, topic?: unknown }
-    const name = typeof o.name === 'string' ? o.name.trim() : ''
-    const topic = typeof o.topic === 'string' ? o.topic.trim() : ''
-    return { name: name ? name.slice(0, 24) : undefined, topic: topic ? topic.slice(0, 120) : undefined }
-  } catch {
-    return {}
-  }
+  const o = looseJson(raw.replace(/```(?:json)?/g, ''))
+  if (!o) return {}
+  const name = typeof o.name === 'string' ? o.name.trim() : ''
+  const topic = typeof o.topic === 'string' ? o.topic.trim() : ''
+  return { name: name ? name.slice(0, 24) : undefined, topic: topic ? topic.slice(0, 120) : undefined }
 }
 
 /**
  * 每轮结束后根据聊天内容整理会话名称与主题：后台 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 +51,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 +63,9 @@ export function createRetitle(core: HostState, deps: { touch: () => void, schedu
         '# 名称规则',
         '- 格式：「类别 emoji + 对象｜目标」，例如「🔎 缓存选型｜Redis 与本地 KV 对比」',
         '- 类别固定六选一：🔎 调研对比（多方案/多观点比较）、💡 头脑风暴（创意发散）、⚖️ 方案评审（评审已有方案或产物）、🛠️ 排查修复（定位与解决问题）、📝 方法整理（总结沉淀方法与知识）、🗣️ 通用讨论（其余兜底）',
-        '- 对象在前且稳定：把辨识度最高的讨论对象放最前；省略群组名（外层已展示）；除非讨论对象实质变化，沿用当前名称里的对象名；「继续」「追问」等不改变主线',
+        '- 对象在前：把辨识度最高的讨论对象放最前；省略群组名（外层已展示）',
         '- 目标 = 当前正在做的事，动宾短语，保持简洁',
-        '- 名称总长不超过 16 个字',
+        '- 名称总长不超过 16 个字；名称只生成一次，不要为了追问/继续而改名',
         '',
         '# 主题规则',
         '- 一句话演进式摘要：讨论对象 + 当前目标 + 当前焦点/分歧点',
@@ -92,7 +75,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 +103,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 })

package/src/host/materials/materials.ts

@@ -64,6 +64,8 @@ export function createMaterials(core: HostState): Materials {
 
   /** 逐候选 stat，返回第一个存在的目标；都不存在时返回首候选与全部尝试。 */
   const resolveMaterialTarget = async (raw: unknown) => {
+    // candidatePaths 构造上恒返回非空候选数组（'' → [HOME]，其余分支均单值或
+    // 非空 map），first 必在；! 仅为取首候选，无空指针风险
     const candidates = await candidatePaths(raw)
     let first: { target: import('@deepseek-ai/dsh-fs').FsTarget, path: string } | undefined
     for (const c of candidates) {

package/src/host/persistence/persistence.ts

@@ -5,7 +5,9 @@
  */
 
 import { existsSync } from 'node:fs'
+import { repairFailedMessage } from '../../core/errors.ts'
 import { messageJson, roleJson } from '../../core/json.ts'
+import { sanitizeConstraints } from '../../core/constraints.ts'
 import { asNumber, migrateTier } from '../../core/types.ts'
 import type { GroupRecord, MessageRecord, RoleRecord, SessionRecord } from '../../core/types.ts'
 import { emptyGroup, LedgerDocument, scanGroupIds, scanSessionIds, STORE_DIR, Store } from './store.ts'
@@ -17,6 +19,8 @@ interface SessionDocument {
   topic?: string
   namePinned?: boolean
   topicPinned?: boolean
+  constraints?: unknown
+  constraintsUpToSeq?: number
   createdAt?: number
   messages?: Partial<MessageRecord>[]
 }
@@ -74,6 +78,8 @@ export function createPersistence(core: HostState): Persistence {
     topic: s.topic,
     ...(s.namePinned ? { namePinned: true } : {}),
     ...(s.topicPinned ? { topicPinned: true } : {}),
+    ...(s.constraints && s.constraints.length ? { constraints: s.constraints } : {}),
+    ...(typeof s.constraintsUpToSeq === 'number' && s.constraintsUpToSeq > 0 ? { constraintsUpToSeq: s.constraintsUpToSeq } : {}),
     createdAt: s.createdAt,
     messages: s.messageIds.map((mid) => core.messages.get(mid)).filter(Boolean).map((m) => messageJson(m)).filter(Boolean),
   })
@@ -178,6 +184,9 @@ export function createPersistence(core: HostState): Persistence {
       if (typeof doc.topic === 'string') sess.topic = doc.topic
       if (doc.namePinned === true) sess.namePinned = true
       if (doc.topicPinned === true) sess.topicPinned = true
+      const constraints = sanitizeConstraints(doc.constraints)
+      if (constraints.length) sess.constraints = constraints
+      if (typeof doc.constraintsUpToSeq === 'number' && doc.constraintsUpToSeq > 0) sess.constraintsUpToSeq = doc.constraintsUpToSeq
       if (typeof doc.createdAt === 'number') sess.createdAt = doc.createdAt
       let fallbackSeq = 0
       for (const m of (Array.isArray(doc.messages) ? doc.messages : [])) {
@@ -194,11 +203,19 @@ export function createPersistence(core: HostState): Persistence {
           thinkingSummary: m.thinkingSummary !== undefined ? String(m.thinkingSummary) : undefined,
           model: m.model,
           error: m.error,
+          failedRoleId: typeof m.failedRoleId === 'string' && m.failedRoleId ? m.failedRoleId : undefined,
           toolCalls: Array.isArray(m.toolCalls) ? m.toolCalls : undefined,
           ts: typeof m.ts === 'number' ? m.ts : Date.now(),
         })
         sess.messageIds.push(m.id)
       }
+      const groupRoles = g.roleIds.map((rid) => core.roles.get(rid)).filter((r): r is RoleRecord => Boolean(r))
+      let repaired = false
+      for (const mid of sess.messageIds) {
+        const rec = core.messages.get(mid)
+        if (rec && repairFailedMessage(rec, groupRoles)) repaired = true
+      }
+      if (repaired) schedulePersist({ session: sid })
     }
     core.sessions.set(sid, sess)
     g.sessionIds.push(sid)
@@ -274,7 +291,7 @@ export function createPersistence(core: HostState): Persistence {
     if (core.groups.size === 0) {
       const g: GroupRecord = { id: core.nid('grp'), name: '默认群组', workspaceDir: '', permissionTier: 'view_only', roleIds: [], sessionIds: [] }
       core.groups.set(g.id, g)
-      const sess = core.newSession(g.id, '会话 1')
+      const sess = core.newSession(g.id)
       g.sessionIds.push(sess.id)
       autoSessions.push(sess.id)
     }

package/src/host/service.ts

@@ -6,7 +6,7 @@
  *   persistence/   持久化（store 文件原语 + 脏标记合并落盘 + 启动恢复）
  *   materials/     资料读取与路径解析 + 目录浏览器
  *   tools/         工具执行（沙箱 + 确认闸门）
- *   engine/        对话引擎（conversation：speak/runLoop；retitle：标题整理）
+ *   engine/        对话引擎（conversation：speak/runLoop；retitle：标题整理；fold：窗口外约束）
  *   api/           HTTP 传输（http 护栏 + routes 路由）与动作分发（actions）
  * @module dsh-group-chat/host/service
  */

package/src/host/state.ts

@@ -28,6 +28,9 @@ declare module '@deepseek-ai/cordis' {
 /** 角色标识色板（新增角色依序取色）。 */
 export const PALETTE = ['#5b8def', '#22a06b', '#e8912d', '#c678dd', '#e05661', '#56b6c2', '#98c379', '#d19a66']
 
+/** 新建会话默认名称（自动标题只在仍为此占位名时生成一次）。 */
+export const DEFAULT_SESSION_NAME = '新会话'
+
 /** 宿主服务共享状态容器（见模块注释；可变原始值一律经 core.* 访问）。 */
 export interface HostState {
   ctx: Context
@@ -60,19 +63,17 @@ export function createHostState(ctx: Context): HostState {
     sessions: new Map(),
     roles: new Map(),
     messages: new Map(),
-    run: { running: false, sessionId: null, currentRoleId: null, partial: '', partialReasoning: '', stopping: false, queue: [], pendingConfirm: null, confirmSignal: null, childProc: null, finished: null },
+    run: { running: false, sessionId: null, currentRoleId: null, partial: '', partialReasoning: '', stopping: false, queue: [], pendingConfirm: null, confirmSignal: null, childProc: null, finished: null, replaceMessageId: null },
     store: null,
     revision: 1,
     idSeq: 1,
     nid: (p: string): string => p + '-' + (core.idSeq++),
     lastCreated: null,
     newSession: (groupId: string, name?: string): SessionRecord => {
-      let n = 0
-      for (const s of core.sessions.values()) if (s.groupId === groupId) n++
       const s: SessionRecord = {
         id: randomUUID(),
         groupId,
-        name: name || '会话 ' + (n + 1),
+        name: name || DEFAULT_SESSION_NAME,
         topic: '',
         messageIds: [],
         createdAt: Date.now(),

package/src/host/tools/tools.ts

@@ -9,7 +9,7 @@ import { spawn, type ChildProcess } from 'node:child_process'
 import { closeSync, openSync, readSync, readdirSync, realpathSync, statSync } from 'node:fs'
 import { isAbsolute, join, sep } from 'node:path'
 import { CMD_CAPTURE_MAX_BYTES, CMD_OUTPUT_MAX_CHARS, READ_FILE_MAX_BYTES, RUN_CMD_TIMEOUT_MS, TOOL_SCHEMAS } from '../../core/tools.ts'
-import type { GroupRecord, RunState, ToolExecution } from '../../core/types.ts'
+import type { GroupRecord, PendingConfirm, ToolExecution } from '../../core/types.ts'
 import type { HostState } from '../state.ts'
 
 /** 工具面。 */
@@ -134,7 +134,7 @@ export function createTools(core: HostState, touch: () => void): Tools {
 
   /** run_command 确认闸门：置 pendingConfirm 后无限等待，confirmCommand/stop/dispose 唤醒。 */
   const requestConfirmation = (toolCallId: string, args: Record<string, unknown>): Promise<boolean> => new Promise((resolve) => {
-    run.pendingConfirm = { toolCallId, tool: 'run_command', args: args as RunState['pendingConfirm'] extends null ? never : NonNullable<RunState['pendingConfirm']>['args'] }
+    run.pendingConfirm = { toolCallId, tool: 'run_command', args: args as PendingConfirm['args'] }
     run.confirmSignal = { resolve }
     touch()
   })

package/src/index.ts

@@ -10,6 +10,8 @@
  *    数据模型：Group 1..N Session，消息挂在会话上；角色与工作区目录挂在群组上
  *  - 群组与会话的增删改；群组/会话检索由客户端在快照上过滤
  *  - 角色发言经 `llm` 服务流式生成，按角色绑定的 provider/model 路由
+ *  - 整次 runLoop 结束后后台折叠被 40 条窗口挤出的消息为会话级约束备忘
+ *    （engine/fold.ts；立刻 idle、fire-and-forget，不产生消息）
  *  - 群组工作区目录经 `fs` 服务读取（根下一层文本文件，最多 20 个），
  *    以「共享资料」块注入每个角色的 system 提示词；无独立笔记/文件清单
  *  - 经 `webServer` 暴露 HTTP API：