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

package/src/core/errors.ts

@@ -0,0 +1,174 @@
+/**
+ * 角色发言失败：供应商原文 → 人话标题/原因（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
+}
+
+import { looseJson } from './json.ts'
+
+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 = looseJson(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
 }
@@ -26,3 +27,20 @@ export function roleJson(r: Partial<RoleRecord>): Record<string, unknown> {
   if (typeof r.reasoningEffort === 'string' && r.reasoningEffort && r.reasoningEffort !== 'default') o.reasoningEffort = r.reasoningEffort
   return o
 }
+
+/**
+ * 宽容 JSON 提取（模型输出/供应商错误原文的统一解析入口）：
+ * 取首个 { 至末个 } 的片段解析，仅接受普通对象；失败返回 null。
+ * 代码围栏剥离由调用方按需先行处理（供应商错误原文不剥）。
+ */
+export function looseJson(raw: string): Record<string, unknown> | null {
+  const start = raw.indexOf('{')
+  const end = raw.lastIndexOf('}')
+  if (start < 0 || end <= start) return null
+  try {
+    const parsed = JSON.parse(raw.slice(start, end + 1)) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : null
+  } catch {
+    return null
+  }
+}

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
 }
 
 /** 角色发言的引擎产物。 */
@@ -177,31 +202,39 @@ export interface FileSearchResult {
   error?: string
 }
 
-/** 发到客户端的全量快照（wire 形态）。 */
+/** 快照内的会话行（wire 形态：不含 hydrate 用的固定标记与折入水位）。 */
+export type SnapshotSession = Omit<SessionRecord, 'namePinned' | 'topicPinned' | 'constraintsUpToSeq'>
+/** 快照内的消息行（wire 形态：思考全文与摘要不外发）。 */
+export type SnapshotMessage = Omit<MessageRecord, 'reasoningFull' | 'thinkingSummary'>
+
+/** 发到客户端的全量快照（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: Omit<RunState, 'stopping' | 'queue' | 'confirmSignal' | 'childProc'>
   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 }[]
-  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 }[]
+  groups: GroupRecord[]
+  sessions: SnapshotSession[]
+  roles: RoleRecord[]
+  messages: SnapshotMessage[]
   error?: string
 }
 
-/** mutate 动作的参数形态（op 分发见 host/service）。 */
-export interface MutateArgs {
-  op: string
-  groupId?: string
-  sessionId?: string
-  roleId?: string
-  role?: Partial<RoleRecord>
-  name?: string
-  topic?: string
-  path?: string
-  tier?: string
-  enabled?: boolean
-}
+/** mutate 动作的参数形态（判别联合：按 op 收窄各分支字段；wire 上字段可缺，消费方各自守卫）。 */
+export type MutateArgs =
+  | { op: 'createGroup', name?: string }
+  | { op: 'renameGroup', groupId: string, name?: string }
+  | { op: 'deleteGroup', groupId: string }
+  | { op: 'createSession', groupId: string, name?: string }
+  | { op: 'renameSession', sessionId: string, name?: string }
+  | { op: 'deleteSession', sessionId: string }
+  | { op: 'setTopic', sessionId: string, topic?: string }
+  | { op: 'upsertRole', groupId: string, role?: Partial<RoleRecord> }
+  | { op: 'deleteRole', roleId: string }
+  | { op: 'setRoleEnabled', roleId: string, enabled?: boolean }
+  | { op: 'setWorkspaceDir', groupId: string, path?: string }
+  | { op: 'setPermissionTier', groupId: string, tier?: string }
+  | { op: 'ackFinish' }
+  | { op: 'clearMessages', sessionId: string }
 
 /** send 动作的参数形态。 */
 export interface SendArgs {

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'
@@ -35,7 +36,8 @@ export function createActions(core: HostState, deps: {
   const { touch, snapshot, schedulePersist, dropDirty, appendMessage, runLoop, wakeConfirm, killChild, browse, fileSearch, disposeFileSearch } = deps
 
   const mutate = (args: MutateArgs): Snapshot => {
-    const op = args && args.op
+    // 直接属性别名保持判别联合收窄（调用方 handleAction 已保证 body 为对象）
+    const op = args.op
     if (op === 'createGroup') {
       const g: GroupRecord = { id: core.nid('grp'), name: String(args.name || '').trim() || '群组 ' + (groups.size + 1), workspaceDir: '', permissionTier: 'view_only', roleIds: [], sessionIds: [] }
       groups.set(g.id, g)
@@ -45,14 +47,14 @@ export function createActions(core: HostState, deps: {
       schedulePersist({ ledger: true, session: sess.id })
       touch()
     } else if (op === 'renameGroup') {
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       if (g && String(args.name || '').trim()) {
         g.name = String(args.name).trim()
         schedulePersist({ ledger: true })
         touch()
       }
     } else if (op === 'deleteGroup') {
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       if (!g) return { ...snapshot(), error: '群组不存在' }
       if (groups.size <= 1) return { ...snapshot(), error: '至少保留一个群组' }
       if (run.running) {
@@ -79,7 +81,7 @@ export function createActions(core: HostState, deps: {
       schedulePersist({ ledger: true })
       touch()
     } else if (op === 'createSession') {
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       if (!g) return { ...snapshot(), error: '群组不存在' }
       const sess = core.newSession(g.id, String(args.name || '').trim() || undefined)
       g.sessionIds.push(sess.id)
@@ -87,7 +89,7 @@ export function createActions(core: HostState, deps: {
       schedulePersist({ ledger: true, session: sess.id })
       touch()
     } else if (op === 'renameSession') {
-      const sess = sessions.get(args.sessionId!)
+      const sess = sessions.get(args.sessionId)
       if (sess && String(args.name || '').trim()) {
         sess.name = String(args.name).trim()
         sess.namePinned = true // 手动编辑 = 隐式固定：自动命名此后跳过名称
@@ -95,7 +97,7 @@ export function createActions(core: HostState, deps: {
         touch()
       }
     } else if (op === 'deleteSession') {
-      const sess = sessions.get(args.sessionId!)
+      const sess = sessions.get(args.sessionId)
       if (!sess) return { ...snapshot(), error: '会话不存在' }
       const g = groups.get(sess.groupId)
       if (g && g.sessionIds.length <= 1) return { ...snapshot(), error: '每个群组至少保留一个会话' }
@@ -114,7 +116,7 @@ export function createActions(core: HostState, deps: {
       schedulePersist({ ledger: true })
       touch()
     } else if (op === 'setTopic') {
-      const sess = sessions.get(args.sessionId!)
+      const sess = sessions.get(args.sessionId)
       if (sess) {
         sess.topic = String(args.topic || '')
         sess.topicPinned = true // 手动编辑 = 隐式固定：自动整理此后跳过主题
@@ -122,7 +124,7 @@ export function createActions(core: HostState, deps: {
         touch()
       }
     } else if (op === 'upsertRole') {
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       const r = args.role || {}
       if (!g) return { ...snapshot(), error: '群组不存在' }
       if (!r.name || !String(r.name).trim()) return { ...snapshot(), error: '角色名称不能为空' }
@@ -160,7 +162,7 @@ export function createActions(core: HostState, deps: {
         touch()
       }
     } else if (op === 'deleteRole') {
-      const r = roles.get(args.roleId!)
+      const r = roles.get(args.roleId)
       if (r) {
         const gid = r.groupId
         const g = groups.get(gid)
@@ -170,14 +172,14 @@ export function createActions(core: HostState, deps: {
         touch()
       }
     } else if (op === 'setRoleEnabled') {
-      const r = roles.get(args.roleId!)
+      const r = roles.get(args.roleId)
       if (r) {
         r.enabled = !!args.enabled
         schedulePersist({ roles: r.groupId })
         touch()
       }
     } else if (op === 'setWorkspaceDir') {
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       if (g) {
         g.workspaceDir = String(args.path || '').trim()
         schedulePersist({ workspace: g.id })
@@ -186,7 +188,7 @@ export function createActions(core: HostState, deps: {
     } else if (op === 'setPermissionTier') {
       const tier = asPermissionTier(args.tier)
       if (!tier) return { ...snapshot(), error: '未知权限档位' }
-      const g = groups.get(args.groupId!)
+      const g = groups.get(args.groupId)
       if (g) {
         g.permissionTier = tier
         // 降到仅可查看时若该群挂着待确认命令，自动拒绝（安全侧倾斜）；
@@ -205,11 +207,13 @@ export function createActions(core: HostState, deps: {
         touch()
       }
     } else if (op === 'clearMessages') {
-      const sess = sessions.get(args.sessionId!)
+      const sess = sessions.get(args.sessionId)
       if (sess) {
         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 +247,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 +356,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 {