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

package/src/client/react-dom-shim.d.ts

@@ -1,6 +1,8 @@
 /** Platform modules (react-dom / client) have no @types in this plugin. */
 declare module 'react-dom' {
+  import type { ReactNode } from 'react'
   export function flushSync(fn: () => void): void
+  export function createPortal(children: ReactNode, container: Element | DocumentFragment): ReactNode
 }
 
 declare module 'react-dom/client' {

package/src/core/constraints.ts

@@ -0,0 +1,210 @@
+/**
+ * 会话约束备忘纯逻辑：滑动 40 条窗口、挤出集、压行、临时原文、解析与截断。
+ * @module dsh-group-chat/core/constraints
+ */
+
+import { TRANSCRIPT_TOOL_SUMMARY } from './tools.ts'
+import { asConstraintKind, type MessageRecord, type SessionConstraint, type SessionRecord } from './types.ts'
+
+/** 当场原文窗口（含系统行）。 */
+export const WINDOW_SIZE = 40
+/** 折叠失败时临时原文条数上限。 */
+export const TEMP_MAX_MESSAGES = 20
+/** 折叠失败时临时原文总长上限。 */
+export const TEMP_MAX_CHARS = 16000
+/** 单轮折叠最多消耗的挤出条数（含系统行；超出留待下一轮）。 */
+export const FOLD_MAX_MESSAGES = 40
+/** 单轮折叠输入总长上限（格式化后）。 */
+export const FOLD_MAX_CHARS = 16000
+/** 备忘条数上限。 */
+export const CONSTRAINT_MAX_ITEMS = 12
+/** 备忘总长上限（条目前缀+正文）。 */
+export const CONSTRAINT_MAX_CHARS = 1200
+/** 单条备忘正文上限。 */
+export const CONSTRAINT_ITEM_MAX_CHARS = 160
+
+export const KIND_LABEL: Record<SessionConstraint['kind'], string> = {
+  decided: '已定',
+  rejected: '否决',
+  open: '未决',
+}
+
+/** 已折入水位（缺省 0）。 */
+export function constraintsWatermark(sess: SessionRecord): number {
+  return typeof sess.constraintsUpToSeq === 'number' && sess.constraintsUpToSeq > 0 ? sess.constraintsUpToSeq : 0
+}
+
+/** 重试：只取失败卡之前的时间线；untilId 不在列表则原样。 */
+export function prefixIds(ids: string[], untilId?: string): string[] {
+  if (!untilId) return ids
+  const i = ids.indexOf(untilId)
+  return i >= 0 ? ids.slice(0, i) : ids
+}
+
+/**
+ * 新挤出：seq > 水位 且不在最近 40 条。只扫窗口外前缀（旧→新）。
+ * untilId：重试时把窗口截到该消息之前，不带上后面已经发生的发言。
+ */
+export function squeezedMessages(
+  messages: Map<string, MessageRecord>,
+  sess: SessionRecord,
+  untilId?: string,
+): MessageRecord[] {
+  const ids = prefixIds(sess.messageIds, untilId)
+  if (ids.length <= WINDOW_SIZE) return []
+  const end = ids.length - WINDOW_SIZE
+  const upTo = constraintsWatermark(sess)
+  const last = messages.get(ids[end - 1])
+  if (last && last.seq <= upTo) return []
+  const out: MessageRecord[] = []
+  for (let i = 0; i < end; i++) {
+    const m = messages.get(ids[i])
+    if (!m || m.seq <= upTo) continue
+    out.push(m)
+  }
+  return out
+}
+
+/** 说话人展示名（折叠输入 / transcript 共用）。 */
+export function speakerLabel(speaker: string, roleName?: string): string {
+  if (speaker === 'user') return '用户'
+  if (speaker === 'system') return '系统'
+  return roleName || '成员'
+}
+
+/** 单条消息压成 transcript 行（正文 8k + 工具一行摘要）。 */
+export function formatTranscriptLine(m: MessageRecord, name: string): string {
+  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, ' ') + '）' : '')
+    }
+  }
+  return line
+}
+
+/**
+ * 单轮折叠消耗前缀：从最旧挤出起，最多 40 条 / 16k；系统行与失败卡计入消耗但不进模型。
+ * 水位只能推到 consumed 的 max seq，剩余留待下一轮。
+ */
+export function takeFoldBatch(squeezed: MessageRecord[], nameOf: (m: MessageRecord) => string): {
+  consumed: MessageRecord[]
+  lines: string[]
+  hasUser: boolean
+  allSystem: boolean
+} {
+  const consumed: MessageRecord[] = []
+  const lines: string[] = []
+  let hasUser = false
+  let chars = 0
+  for (const m of squeezed) {
+    if (m.speaker === 'system' || m.error) {
+      consumed.push(m)
+      if (consumed.length >= FOLD_MAX_MESSAGES) break
+      continue
+    }
+    const line = formatTranscriptLine(m, nameOf(m))
+    const extra = line.length + (lines.length ? 2 : 0)
+    if (lines.length > 0 && chars + extra > FOLD_MAX_CHARS) break
+    if (m.speaker === 'user') hasUser = true
+    lines.push(line)
+    chars += extra
+    consumed.push(m)
+    if (consumed.length >= FOLD_MAX_MESSAGES) break
+  }
+  return { consumed, lines, hasUser, allSystem: lines.length === 0 }
+}
+
+/**
+ * 未折入的挤出原文（失败缓冲）：只格式化最近 20 条，再按 16k 从最旧往下丢。
+ */
+export function tempTranscript(squeezed: MessageRecord[], nameOf: (m: MessageRecord) => string): string {
+  if (!squeezed.length) return ''
+  const usable = squeezed.filter((m) => m.speaker !== 'system' && !m.error)
+  if (!usable.length) return ''
+  const batch = usable.length > TEMP_MAX_MESSAGES ? usable.slice(-TEMP_MAX_MESSAGES) : usable
+  const lines = batch.map((m) => formatTranscriptLine(m, nameOf(m)))
+  let start = 0
+  let total = lines[0] ? lines[0].length : 0
+  for (let i = 1; i < lines.length; i++) {
+    total += 2 + lines[i].length
+  }
+  while (start < lines.length - 1 && total > TEMP_MAX_CHARS) {
+    total -= lines[start].length + 2
+    start++
+  }
+  let block = lines.slice(start).join('\n\n')
+  if (block.length > TEMP_MAX_CHARS) block = block.slice(0, TEMP_MAX_CHARS) + '…(已截断)'
+  return block
+}
+
+/** 水位 = 本批挤出的 max(seq)；空批为 0。 */
+export function squeezedMaxSeq(squeezed: MessageRecord[]): number {
+  let max = 0
+  for (const m of squeezed) if (m.seq > max) max = m.seq
+  return max
+}
+
+/** hydrate / 模型输出：非法 kind 丢条目；空 text 丢；条数与总长截断。 */
+export function sanitizeConstraints(raw: unknown): SessionConstraint[] {
+  if (!Array.isArray(raw)) return []
+  const out: SessionConstraint[] = []
+  let total = 0
+  for (const item of raw) {
+    if (out.length >= CONSTRAINT_MAX_ITEMS) break
+    if (!item || typeof item !== 'object') continue
+    const kind = asConstraintKind((item as { kind?: unknown }).kind)
+    const text = typeof (item as { text?: unknown }).text === 'string' ? (item as { text: string }).text.trim() : ''
+    if (!kind || !text) continue
+    const clipped = text.length > CONSTRAINT_ITEM_MAX_CHARS ? text.slice(0, CONSTRAINT_ITEM_MAX_CHARS) + '…' : text
+    const cost = KIND_LABEL[kind].length + clipped.length
+    if (total + cost > CONSTRAINT_MAX_CHARS) break
+    out.push({ kind, text: clipped })
+    total += cost
+  }
+  return out
+}
+
+/**
+ * 解析折叠模型输出。null = 解析失败（水位不推）；[] = 无新结论（水位推、备忘不动）。
+ */
+export function parseConstraints(raw: string): SessionConstraint[] | null {
+  const body = raw.replace(/```(?:json)?/g, '')
+  const l = body.indexOf('{')
+  const r = body.lastIndexOf('}')
+  if (l < 0 || r <= l) return null
+  try {
+    const o = JSON.parse(body.slice(l, r + 1)) as { constraints?: unknown }
+    if (!Object.prototype.hasOwnProperty.call(o, 'constraints')) return null
+    if (!Array.isArray(o.constraints)) return null
+    return sanitizeConstraints(o.constraints)
+  } catch {
+    return null
+  }
+}
+
+/** 本批无用户消息时，新的已定/否决降为未决。 */
+export function downgradeWithoutUser(list: SessionConstraint[], hasUser: boolean): SessionConstraint[] {
+  if (hasUser) return list
+  return list.map((c) => c.kind === 'open' ? c : { kind: 'open', text: c.text })
+}
+
+/** system 提示词「已确认约束」块；空则空串。 */
+export function constraintBlock(list: SessionConstraint[] | undefined): string {
+  if (!list || !list.length) return ''
+  const lines = list.map((c) => '- ' + KIND_LABEL[c.kind] + '：' + c.text)
+  return '\n# 已确认约束\n' + lines.join('\n')
+}

package/src/core/errors.ts

@@ -0,0 +1,184 @@
+/**
+ * 角色发言失败：供应商原文 → 人话标题/原因（core 纯函数，无 React）。
+ * 原始 JSON 仍落盘在消息 text 里，UI 默认只展示短因，展开才看原文。
+ * @module dsh-group-chat/core/errors
+ */
+
+export interface SpeakFailureView {
+  /** 一行标题，例如「额度已用尽」。 */
+  title: string
+  /** 可选短因：重置时间、HTTP 状态等。 */
+  detail?: string
+  /** 复制/排障用的供应商原文（已剥「模型输出异常终止: 」前缀）。 */
+  raw: string
+}
+
+const PREFIX = '模型输出异常终止: '
+const LEGACY_ROLE = /^角色「([^」]+)」发言失败[:：]\s*/
+
+/** 剥旧系统胶囊与引擎包装前缀，保留供应商原文。 */
+export function unwrapSpeakFailure(raw: string): string {
+  const text = String(raw || '').trim()
+  const legacy = parseLegacyRoleFailure(text)
+  const body = legacy ? legacy.rest : text
+  return body.startsWith(PREFIX) ? body.slice(PREFIX.length).trim() : body
+}
+
+/** 旧系统胶囊文案：角色「名」发言失败：原文。对不上则 null。 */
+export function parseLegacyRoleFailure(text: string): { roleName: string, rest: string } | null {
+  const m = LEGACY_ROLE.exec(String(text || ''))
+  if (!m) return null
+  return { roleName: m[1], rest: String(text).slice(m[0].length) }
+}
+
+export interface RoleRef {
+  id: string
+  name: string
+  provider?: string
+  model?: string
+}
+
+export interface FailedMessageRef {
+  speaker: string
+  text: string
+  error?: boolean
+  failedRoleId?: string
+}
+
+/** 发言失败卡：error 标记，或旧系统胶囊文案。 */
+export function isSpeakFailure(m: FailedMessageRef): boolean {
+  return !!m.error || !!parseLegacyRoleFailure(m.text)
+}
+
+/** 失败回合对应角色：failedRoleId / speaker / 旧文案里的角色名（恰好一名才命中）。 */
+export function resolveFailedRole<T extends RoleRef>(m: FailedMessageRef, roles: T[]): T | null {
+  const byId = (id: string | undefined): T | null => {
+    if (!id) return null
+    for (const r of roles) if (r.id === id) return r
+    return null
+  }
+  const direct = byId(m.failedRoleId) || (m.speaker !== 'user' && m.speaker !== 'system' ? byId(m.speaker) : null)
+  if (direct) return direct
+  const parsed = parseLegacyRoleFailure(m.text)
+  if (!parsed) return null
+  const hits = roles.filter((r) => r.name === parsed.roleName)
+  return hits.length === 1 ? hits[0] : null
+}
+
+/**
+ * 把旧系统失败行挂到对应角色（恰好一名命中才迁）。
+ * 返回是否改写了记录。
+ */
+export function repairFailedMessage(
+  m: { speaker: string, text: string, error?: boolean, failedRoleId?: string, model?: string },
+  roles: RoleRef[],
+): boolean {
+  if (!isSpeakFailure(m)) return false
+  let changed = false
+  if (!m.error) {
+    m.error = true
+    changed = true
+  }
+  if (!m.failedRoleId && m.speaker !== 'user' && m.speaker !== 'system') {
+    m.failedRoleId = m.speaker
+    changed = true
+  }
+  if (!m.failedRoleId && m.speaker === 'system') {
+    const parsed = parseLegacyRoleFailure(m.text)
+    if (parsed) {
+      const hits = roles.filter((r) => r.name === parsed.roleName)
+      if (hits.length === 1) {
+        const role = hits[0]
+        m.speaker = role.id
+        m.failedRoleId = role.id
+        m.text = unwrapSpeakFailure(parsed.rest)
+        if (!m.model && (role.provider || role.model)) m.model = (role.provider || '') + ' / ' + (role.model || '')
+        changed = true
+      }
+    }
+  } else if (m.failedRoleId && m.speaker === 'system') {
+    m.speaker = m.failedRoleId
+    changed = true
+  }
+  // 对不上角色时保留「角色「名」发言失败」原文，客户端才能再解析。
+  if (m.failedRoleId || (m.speaker !== 'user' && m.speaker !== 'system')) {
+    const unwrapped = unwrapSpeakFailure(m.text)
+    if (unwrapped !== m.text) {
+      m.text = unwrapped
+      changed = true
+    }
+  }
+  return changed
+}
+
+function pickJsonBlob(text: string): Record<string, unknown> | null {
+  const start = text.indexOf('{')
+  const end = text.lastIndexOf('}')
+  if (start < 0 || end <= start) return null
+  try {
+    const parsed = JSON.parse(text.slice(start, end + 1)) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null
+  } catch {
+    return null
+  }
+}
+
+function httpStatus(text: string): number | null {
+  const m = text.match(/\b([1-5]\d{2})\b/)
+  if (!m) return null
+  const n = Number(m[1])
+  return n >= 100 && n <= 599 ? n : null
+}
+
+function resetHint(message: string): string | undefined {
+  const m = message.match(/reset at ([^.]+\S)/i) || message.match(/将在\s*([^\s。]+)\s*重置/)
+  return m ? '将在 ' + m[1] + ' 重置' : undefined
+}
+
+/**
+ * 把供应商错误压成可扫描的标题 + 短因。
+ * 未知形态回退为「发言失败」，原文仍可展开。
+ */
+export function classifySpeakFailure(raw: string): SpeakFailureView {
+  const source = unwrapSpeakFailure(raw)
+  const blob = pickJsonBlob(source)
+  const code = blob && typeof blob.code === 'string' ? blob.code : ''
+  const type = blob && typeof blob.type === 'string' ? blob.type : ''
+  const message = blob && typeof blob.message === 'string' ? blob.message : source
+  const status = httpStatus(source)
+  const joined = (code + ' ' + type + ' ' + message + ' ' + source).toLowerCase()
+
+  if (/quota|accountquotaexceeded|exceeded the .*quota|额度|配额/.test(joined) || code === 'AccountQuotaExceeded') {
+    return { title: '额度已用尽', detail: resetHint(message), raw: source }
+  }
+  if (status === 429 || /too.?many.?requests|rate.?limit|限流/.test(joined) || type === 'TooManyRequests') {
+    return { title: '请求过于频繁', detail: '稍后再试，或降低并发', raw: source }
+  }
+  if (status === 401 || status === 403 || /unauthorized|forbidden|invalid.?api.?key|鉴权|未授权/.test(joined)) {
+    return { title: '模型鉴权失败', detail: '检查该角色绑定的提供方密钥', raw: source }
+  }
+  if (status === 404 || /model.?not.?found|unknown.?model|模型不存在/.test(joined)) {
+    return { title: '模型不可用', detail: '该角色绑定的模型可能已下线', raw: source }
+  }
+  if (/timeout|timed out|etimedout|超时/.test(joined)) {
+    return { title: '模型响应超时', raw: source }
+  }
+  if (/network|econnreset|econnrefused|enotfound|fetch failed|网络/.test(joined)) {
+    return { title: '网络异常', detail: '检查网络后重试', raw: source }
+  }
+  if (status !== null && status >= 500) {
+    return { title: '模型服务暂时不可用', detail: 'HTTP ' + status, raw: source }
+  }
+  if (status !== null) {
+    return { title: '发言失败', detail: 'HTTP ' + status, raw: source }
+  }
+  return { title: '发言失败', raw: source }
+}
+
+/** 失败卡默认复制内容：标题 + 短因 + 原文。 */
+export function formatSpeakFailureCopy(view: SpeakFailureView): string {
+  const lines = [view.title]
+  if (view.detail) lines.push(view.detail)
+  if (view.raw && view.raw !== view.title) lines.push(view.raw)
+  return lines.join('\n')
+}

package/src/core/json.ts

@@ -14,6 +14,7 @@ export function messageJson(m: Partial<MessageRecord> | undefined): Record<strin
   if (m.reasoningFull !== undefined) o.reasoningFull = m.reasoningFull
   if (m.thinkingSummary !== undefined) o.thinkingSummary = m.thinkingSummary
   if (m.error !== undefined) o.error = m.error
+  if (typeof m.failedRoleId === 'string' && m.failedRoleId) o.failedRoleId = m.failedRoleId
   if (Array.isArray(m.toolCalls) && m.toolCalls.length > 0) o.toolCalls = m.toolCalls
   return o
 }

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 {