Преглед изворни кода

发布 v0.4.19:升级普通聊天 v2 并修复发送与检查点恢复

Samien пре 2 месеци
родитељ
комит
71234eeaa3
71 измењених фајлова са 3334 додато и 828 уклоњено
  1. 6 6
      README.md
  2. 2 1
      bin/desktop-service-sync.mjs
  3. 8 4
      bin/lib/service-update.mjs
  4. 1 1
      desktop/boot.html
  5. 8 0
      desktop/boot.js
  6. 12 2
      desktop/main.mjs
  7. 1 0
      desktop/preload.cjs
  8. 11 7
      desktop/service-manager.mjs
  9. 17 0
      desktop/service-manager.test.mjs
  10. 2 2
      desktop/service-sync.mjs
  11. 37 2
      desktop/startup-feedback.test.mjs
  12. 1 1
      docker.env.example
  13. 11 1
      docs/app-web-sync.md
  14. 7 7
      docs/docker-install.md
  15. 1 1
      docs/github-updates.md
  16. 16 1
      docs/local-vm.md
  17. 1 1
      docs/macos-app.md
  18. 49 0
      docs/releases/v0.4.19.md
  19. 75 0
      docs/verification/2026-09-14-ordinary-chat-v2/README.md
  20. 17 0
      docs/verification/2026-09-14-ordinary-chat-v2/verify-fixtures.py
  21. 2 2
      package-lock.json
  22. 1 1
      package.json
  23. 3 3
      release.json
  24. 235 80
      src/client/api/chatTranscript.ts
  25. 2 1
      src/client/api/httpRealtime.ts
  26. 3 1
      src/client/api/realtime.ts
  27. 13 2
      src/client/components/workspace/LocalVmChatPanel.vue
  28. 38 106
      src/client/stores/chat.ts
  29. 14 4
      src/client/utils/cache.ts
  30. 8 3
      src/runner/agent.ts
  31. 76 11
      src/runner/worker/gateway.ts
  32. 92 0
      src/runner/worker/profileSession.ts
  33. 5 7
      src/server/app.ts
  34. 66 75
      src/server/chatCache.ts
  35. 0 55
      src/server/chatEventProjection.ts
  36. 8 7
      src/server/chatTranscriptApi.ts
  37. 1065 113
      src/server/chatTranscriptStore.ts
  38. 6 4
      src/server/grokCloud.ts
  39. 4 1
      src/server/realtimeApi.ts
  40. 18 7
      src/server/realtimeBroker.ts
  41. 6 1
      src/server/runnerHub.ts
  42. 2 2
      src/server/workspaceGateway.ts
  43. 4 2
      src/server/workspaceRuntime.ts
  44. 12 1
      src/server/workspaceStore.ts
  45. 1 1
      src/server/workspaceTeamTools.ts
  46. 73 20
      src/shared/chatTranscript.ts
  47. 2 0
      src/shared/workspace.ts
  48. 233 236
      tests/client/chatCrossClientSync.test.ts
  49. 2 6
      tests/client/chatLifecycle.test.ts
  50. 1 1
      tests/client/chatProtocol.test.ts
  51. 19 0
      tests/client/localVmImages.test.ts
  52. 112 0
      tests/client/ordinaryTranscriptV2.test.ts
  53. 40 0
      tests/client/scopedCache.test.ts
  54. 18 0
      tests/e2e/team-tools.spec.ts
  55. 1 1
      tests/e2e/workspace-chat.spec.ts
  56. 11 11
      tests/e2e/workspace.spec.ts
  57. 135 0
      tests/fixtures/ordinary-chat-v2/protocol.json
  58. 1 1
      tests/fixtures/workspace-server.ts
  59. 65 0
      tests/live/profileComputer.live.test.ts
  60. 12 12
      tests/server/chatCache.test.ts
  61. 4 4
      tests/server/chatCachePagination.test.ts
  62. 1 1
      tests/server/chatCacheRoutes.test.ts
  63. 7 4
      tests/server/chatMessageIdentity.test.ts
  64. 2 2
      tests/server/chatTranscript.test.ts
  65. 36 1
      tests/server/desktopSync.test.ts
  66. 2 1
      tests/server/ordinaryChatLocal.test.ts
  67. 149 0
      tests/server/ordinaryTranscriptApi.test.ts
  68. 246 0
      tests/server/ordinaryTranscriptV2.test.ts
  69. 153 0
      tests/server/profileComputer.test.ts
  70. 16 0
      tests/server/runner.test.ts
  71. 26 0
      tests/server/workspacePanels.test.ts

+ 6 - 6
README.md

@@ -1,6 +1,6 @@
 # 夭夭 AI
 
-当前 Web 与 macOS 桌面发布版本:**v0.4.18**。桌面版提供 Apple Silicon(arm64)DMG,详见 [发布说明](docs/releases/v0.4.18.md)。
+当前 Web 与 macOS 桌面发布版本:**v0.4.19**。桌面版提供 Apple Silicon(arm64)DMG,详见 [发布说明](docs/releases/v0.4.19.md)。
 
 夭夭 AI 为网页、iOS 和安卓提供统一的 Agent、群聊、文件库及语音配置服务。Hermes 通过标准 9119 HTTP/WebSocket 接口执行任务。
 
@@ -38,7 +38,7 @@ Web 数据默认保存在 `~/.yaoyao`,可用 `YAOYAO_HOME` 指定(兼容 `HE
 
 ## macOS 桌面版
 
-在 [v0.4.18 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.18) 下载 `Yaoyao-0.4.18-arm64.dmg`,将“夭夭”拖到应用程序后打开。首次启动会核对并同步配套本机 Web 服务;普通退出保留后台运行,“停止后台服务并退出”可完整停止本应用管理的后台。详细说明见 [macOS App](docs/macos-app.md)。
+在 [v0.4.19 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.19) 下载 `Yaoyao-0.4.19-arm64.dmg`,将“夭夭”拖到应用程序后打开。首次启动会核对并同步配套本机 Web 服务;普通退出保留后台运行,“停止后台服务并退出”可完整停止本应用管理的后台。详细说明见 [macOS App](docs/macos-app.md)。
 
 此 DMG 使用 Apple Development 开发签名,未做 Apple 公证。
 
@@ -48,11 +48,11 @@ Web 数据默认保存在 `~/.yaoyao`,可用 `YAOYAO_HOME` 指定(兼容 `HE
 
 | 镜像 | 架构 |
 | --- | --- |
-| `samienluo/yaoyao:v0.4.18-amd` | AMD64 |
-| `samienluo/yaoyao:v0.4.18` | 自动匹配 AMD64 / ARM64 |
-| `samienluo/yaoyao:latest` | 最新稳定版通用镜像,当前与 `v0.4.18` 相同 |
+| `samienluo/yaoyao:v0.4.19-amd` | AMD64 |
+| `samienluo/yaoyao:v0.4.19` | 自动匹配 AMD64 / ARM64 |
+| `samienluo/yaoyao:latest` | 最新稳定版通用镜像,当前与 `v0.4.19` 相同 |
 
-准备好 Docker Engine/Compose 和容器可访问的 Hermes 9119 服务,在仓库目录将 `docker.env.example` 复制为 `docker.env`。配置上游地址,并设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.18`(或 `samienluo/yaoyao:latest`),即可使用远程镜像:
+准备好 Docker Engine/Compose 和容器可访问的 Hermes 9119 服务,在仓库目录将 `docker.env.example` 复制为 `docker.env`。配置上游地址,并设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.19`(或 `samienluo/yaoyao:latest`),即可使用远程镜像:
 
 ```sh
 docker compose --env-file docker.env pull web

+ 2 - 1
bin/desktop-service-sync.mjs

@@ -12,6 +12,7 @@ let input = ''
 for await (const bytes of process.stdin) { input += bytes; if (input.length > 32768) throw new Error('同步参数过大') }
 try {
   const options = JSON.parse(input)
+  if (options.force !== undefined && typeof options.force !== 'boolean') throw new Error('强制覆盖参数无效')
   const home = resolve(options.home), port = Number(options.port)
   if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('本机服务端口无效')
   if (options.action === 'migrate') {
@@ -32,7 +33,7 @@ try {
   const onProgress = message => process.stdout.write(JSON.stringify({ message }) + '\n')
   const result = options.action==='stop'
     ? await stopDesktopService({home,driver,onProgress})
-    : await synchronizeDesktop({ home, runtimeRoot: resolve(options.runtimeRoot), releaseRoot, driver, onProgress })
+    : await synchronizeDesktop({ home, runtimeRoot: resolve(options.runtimeRoot), releaseRoot, driver, onProgress, force: options.force === true })
   const current = result.current
   process.stdout.write(JSON.stringify({ result: { action: result.action, current: current && {
     version: current.version, commit: current.commit, buildNumber: current.buildNumber, artifactDigest: current.artifactDigest,

+ 8 - 4
bin/lib/service-update.mjs

@@ -280,7 +280,8 @@ export async function transitionService({ home, releaseRoot, driver, finalRoot,
   }
 }
 
-export async function synchronizeDesktop({ home, runtimeRoot, releaseRoot, driver, onProgress = () => {} }) {
+export async function synchronizeDesktop({ home, runtimeRoot, releaseRoot, driver, onProgress = () => {}, force = false }) {
+  if (typeof force !== 'boolean') throw new Error('强制覆盖参数无效')
   mkdirSync(home, { recursive: true, mode: 0o700 })
   const unlock = updateMutex(home), id = randomUUID()
   let release
@@ -291,13 +292,16 @@ export async function synchronizeDesktop({ home, runtimeRoot, releaseRoot, drive
     const target = verifyRuntimePackage(runtimeRoot)
     const marker = join(home, 'updates', 'desktop-sync.json')
     const previous = driver.snapshot(), current = previous ? readRuntime(previous.root) : undefined
-    if (existsSync(marker) && readJSON(marker).artifactDigest === target.artifactDigest && previous) {
+    if (force && current && current.version !== target.version)
+      throw Object.assign(new Error('强制覆盖仅支持相同版本;跨版本更新或回退请使用对应入口'), { code: 'service_force_version_mismatch' })
+    if (!force && existsSync(marker) && readJSON(marker).artifactDigest === target.artifactDigest && previous) {
       if (!previous.wasRunning) { driver.writePlist(previous.plist); await driver.boot() }
       await driver.verify(undefined)
       return { action: 'already-synced', current }
     }
-    const decision = syncDecision(target, current)
-    if (decision === 'unknown') throw new Error('App 与 Web 的构建先后关系无法确定,已保留当前服务;请使用明确的新发布版本')
+    const comparison = syncDecision(target, current)
+    const decision = force && current && comparison !== 'same' ? 'overwrite' : comparison
+    if (decision === 'unknown') throw Object.assign(new Error('App 与 Web 版本相同,但构建先后关系无法确定。可使用当前 App 覆盖 Web;聊天、设置和文件会保留,并先备份。'), { code: 'service_build_unknown' })
     if (decision === 'same' || decision === 'newer') {
       if (!previous.wasRunning) { driver.writePlist(previous.plist); await driver.boot() }
       await driver.verify(undefined)

+ 1 - 1
desktop/boot.html

@@ -2,4 +2,4 @@
 <html lang="zh-CN"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'self'; script-src 'self'; img-src 'self'">
 <title>夭夭</title><link rel="stylesheet" href="boot.css"></head>
-<body><main><img src="icon.png" alt="" width="72" height="72"><h1>夭夭</h1><p id="status" role="status" aria-live="polite">正在启动本地服务…</p><div id="actions" hidden><button id="retry">重试</button><button id="logs">查看日志</button></div></main><script src="boot.js"></script></body></html>
+<body><main><img src="icon.png" alt="" width="72" height="72"><h1>夭夭</h1><p id="status" role="status" aria-live="polite">正在启动本地服务…</p><div id="actions" hidden><button id="force-sync" hidden>使用当前 App 覆盖同版本 Web</button><button id="retry">重试</button><button id="logs">查看日志</button></div></main><script src="boot.js"></script></body></html>

+ 8 - 0
desktop/boot.js

@@ -3,8 +3,16 @@ function display(state) {
   document.getElementById('actions').hidden = !['error','stopped','disconnected'].includes(state.phase)
   document.getElementById('retry').textContent = state.phase === 'disconnected' ? '重新连接' : state.phase === 'stopped' ? '启动后台服务' : '重试'
   document.getElementById('status').setAttribute('role', state.phase === 'error' ? 'alert' : 'status')
+  document.getElementById('force-sync').hidden = state.phase !== 'error' || state.canForceSync !== true
   document.querySelector('main').setAttribute('aria-busy', String(['starting','restarting','stopping'].includes(state.phase)))
 }
+document.getElementById('force-sync').onclick = async () => {
+  const controls = [...document.querySelectorAll('#actions button')]
+  for (const button of controls) button.disabled = true
+  try { await window.yaoyaoDesktop.forceSync(); await render() }
+  catch { display({ phase: 'error', message: '覆盖未完成,请重试或查看服务日志。' }) }
+  finally { for (const button of controls) button.disabled = false }
+}
 async function render() {
   try { display(await window.yaoyaoDesktop.status()) }
   catch { display({ phase: 'error', message: '无法读取启动状态,请重试或查看服务日志。' }) }

+ 12 - 2
desktop/main.mjs

@@ -41,7 +41,7 @@ else {
   const trustedBoot = event => event.sender === window?.webContents && event.senderFrame?.url === bootURL
   ipcMain.handle('desktop:status', event => {
     if (!trustedBoot(event)) throw new Error('不允许此页面访问桌面服务')
-    return { phase: manager?.state.phase || 'starting', message: manager?.state.message || '正在启动…' }
+    return { phase: manager?.state.phase || 'starting', message: manager?.state.message || '正在启动…', canForceSync: manager?.state.canForceSync === true }
   })
   ipcMain.handle('desktop:retry', async event => {
     if (!trustedBoot(event)) throw new Error('不允许此页面启动桌面服务')
@@ -52,6 +52,12 @@ else {
     if (!trustedBoot(event)) throw new Error('不允许此页面读取日志')
     shell.showItemInFolder(logFile)
   })
+  ipcMain.handle('desktop:force-sync', async event => {
+    if (!trustedBoot(event) || event.senderFrame !== window.webContents.mainFrame || closing || quitting || !manager?.canForceSynchronization)
+      throw new Error('不允许此页面覆盖本机 Web')
+    try { await manager.retrySynchronization({ force: true }); return true }
+    catch (error) { log(error.message); return false }
+  })
   const trustedUpdate = event => event.sender === updateWindow?.webContents
     && event.senderFrame === updateWindow.webContents.mainFrame && event.senderFrame.url === updateURL
   ipcMain.handle('desktop:updates', async event => {
@@ -153,6 +159,8 @@ else {
     if (notice) notice.visible = Boolean(state.updateNotice)
     const retrySync = Menu.getApplicationMenu()?.getMenuItemById('desktop-sync-retry')
     if (retrySync) retrySync.enabled = state.phase === 'ready' && Boolean(manager?.options.synchronize)
+    const forceSync = Menu.getApplicationMenu()?.getMenuItemById('desktop-sync-force')
+    if (forceSync) forceSync.enabled = !closing && !quitting && manager?.canForceSynchronization === true
     tray?.setToolTip(`夭夭 · ${state.message}`)
     if (!window || window.isDestroyed()) return
     if (state.phase === 'ready') {
@@ -214,7 +222,7 @@ else {
       stopBackground: (app.isPackaged && !fixtureHome) || (fixtureHome && process.env.HERMES_YAOYAO_DESKTOP_TEST_SYNC === '1')
         ? onProgress => stopLocalService({home,port,root,fixture:Boolean(fixtureHome),onProgress}) : undefined,
       synchronize: (app.isPackaged && !fixtureHome) || (fixtureHome && process.env.HERMES_YAOYAO_DESKTOP_TEST_SYNC === '1')
-        ? onProgress => synchronizeLocalService({ home, port, root, fixture: Boolean(fixtureHome), onProgress,
+        ? (onProgress, { force = false } = {}) => synchronizeLocalService({ home, port, root, fixture: Boolean(fixtureHome), onProgress, force,
           environment: { HERMES_YAOYAO_UPSTREAM: process.env.HERMES_YAOYAO_UPSTREAM || 'http://127.0.0.1:9119', HERMES_YAOYAO_SUPERVISE_DASHBOARD: fixtureHome ? '0' : '1' } })
         : undefined,
       fork: ({ home, port }) => {
@@ -252,6 +260,8 @@ else {
         { id:'desktop-sync-notice', label:'Web 同步待完成:服务忙碌', enabled:false, visible:false },
         { id:'desktop-sync-retry', label:'重试同步本机 Web…', enabled:false,
           click:async()=>{try{await manager.retrySynchronization()}catch(error){log(error.message)}} },
+        { id:'desktop-sync-force', label:'使用当前 App 覆盖同版本 Web', enabled:false,
+          click:async()=>{if(closing||quitting||!manager.canForceSynchronization)return;try{await manager.retrySynchronization({force:true})}catch(error){log(error.message)}} },
         { id:'desktop-login', label:'登录 macOS 时启动', type:'checkbox', enabled:app.isPackaged, checked:app.getLoginItemSettings().openAtLogin,
           click:async item=>{try{app.setLoginItemSettings({openAtLogin:item.checked});item.checked=app.getLoginItemSettings().openAtLogin}catch(error){item.checked=app.getLoginItemSettings().openAtLogin;await dialog.showMessageBox(window,{type:'error',message:'无法修改登录启动设置',detail:error.message})}} },
         { id:'desktop-background', label:'登录启动时仅驻留菜单栏', type:'checkbox', checked:preferences.value.backgroundAtLogin,

+ 1 - 0
desktop/preload.cjs

@@ -2,6 +2,7 @@ const { contextBridge, ipcRenderer } = require('electron')
 contextBridge.exposeInMainWorld('yaoyaoDesktop', Object.freeze({
   status: () => ipcRenderer.invoke('desktop:status'),
   retry: () => ipcRenderer.invoke('desktop:retry'),
+  forceSync: () => ipcRenderer.invoke('desktop:force-sync'),
   logs: () => ipcRenderer.invoke('desktop:logs'),
   openUpdates: () => ipcRenderer.invoke('desktop:updates'),
   openComputer: id => ipcRenderer.invoke('desktop-computer:open', id),

+ 11 - 7
desktop/service-manager.mjs

@@ -52,10 +52,14 @@ export class DesktopServiceManager {
     if (value.phase === 'ready' && this.updateNotice) value = { ...value, updateNotice: this.updateNotice, message: `${value.message},Web 同步待完成` }
     this.state = value; this.options.onState?.(value)
   }
-  async retrySynchronization() {
+  get canForceSynchronization() {
+    return Boolean(this.options.synchronize) && (this.state.canForceSync === true || this.state.phase === 'ready' && this.state.version === this.options.version)
+  }
+  async retrySynchronization({ force = false } = {}) {
     if (this.starting) return this.starting
+    if (force && !this.canForceSynchronization) throw new Error('当前状态不能覆盖同版本 Web')
     this.state = { phase: 'stopped', message: '正在准备同步 Web…' }
-    return this.start()
+    return this.start({ force })
   }
   async reconnect() {
     const generation=this.generation
@@ -102,14 +106,14 @@ export class DesktopServiceManager {
     if (status.server_kind !== 'yaoyao-web') throw new Error('已有端口不是夭夭服务。')
     return { url, pid: Number([...holders][0]), external: true, legacy: true, version: '已有服务' }
   }
-  async start() {
+  async start({ force = false } = {}) {
     if (this.starting) return this.starting
     if (this.state.phase === 'ready' && !this.stopping) return this.state
     this.stopping = false
-    this.starting = this.boot().finally(() => { this.starting = null })
+    this.starting = this.boot({ force }).finally(() => { this.starting = null })
     return this.starting
   }
-  async boot() {
+  async boot({ force = false } = {}) {
     const generation = ++this.generation
     this.publish({ phase: 'starting', message: '正在启动本地服务…' })
     try {
@@ -118,7 +122,7 @@ export class DesktopServiceManager {
       this.root = await realpath(this.options.home)
       this.updateNotice = undefined
       if (this.options.synchronize) {
-        try { await this.options.synchronize(message => this.publish({ phase: 'starting', message })) }
+        try { await this.options.synchronize(message => this.publish({ phase: 'starting', message }), { force }) }
         catch (error) {
           // Busy is reported before stopping or switching. Other failures still
           // fail closed; the existing service must pass the usual identity checks.
@@ -174,7 +178,7 @@ export class DesktopServiceManager {
     } catch (error) {
       if (generation !== this.generation || this.stopping) return
       await this.stopChild()
-      this.publish({ phase: 'error', message: error.message })
+      this.publish({ phase: 'error', message: error.message, canForceSync: error.code === 'service_build_unknown' })
       throw error
     }
   }

+ 17 - 0
desktop/service-manager.test.mjs

@@ -69,3 +69,20 @@ test('a late activate health check cannot reconnect after quit has begun',async(
  await manager.stop();finish();await reconnect
  assert.equal(starts,0);assert.equal(manager.state.phase,'disconnected')
 })
+test('unknown same-version builds offer an explicit one-shot overwrite without changing ordinary retries',async()=>{
+ const home=await realpath(await mkdtemp(join(tmpdir(),'yaoyao-force-sync-'))),attempts=[]
+ const manager=new DesktopServiceManager({home,version:'0.4.18',synchronize:async(_progress,options)=>{
+  attempts.push(options.force)
+  if(attempts.length===1)throw Object.assign(new Error('同版本构建需要选择'),{code:'service_build_unknown'})
+ }})
+ manager.readRecord=async()=>({url:'http://127.0.0.1:1'})
+ manager.verify=async()=>({url:'http://127.0.0.1:1',version:'0.4.18',pid:process.pid})
+ try{
+  await assert.rejects(manager.start(),/需要选择/)
+  assert.equal(manager.state.canForceSync,true);assert.equal(manager.canForceSynchronization,true)
+  await manager.retrySynchronization({force:true});assert.equal(manager.state.phase,'ready')
+  await manager.retrySynchronization();assert.deepEqual(attempts,[false,true,false])
+  manager.state={phase:'error',message:'签名校验失败'}
+  await assert.rejects(manager.retrySynchronization({force:true}),/当前状态不能覆盖/)
+ }finally{await rm(home,{recursive:true,force:true})}
+})

+ 2 - 2
desktop/service-sync.mjs

@@ -6,7 +6,7 @@ import { join } from 'node:path'
 export const synchronizeLocalService = options => serviceCommand({...options,action:'sync'})
 export const stopLocalService = options => serviceCommand({...options,action:'stop'})
 export const migrateLocalData = options => serviceCommand({...options,action:'migrate'})
-function serviceCommand({ home, port, root, fixture, environment, onProgress = () => {}, action }) {
+function serviceCommand({ home, port, root, fixture, environment, onProgress = () => {}, action, force = false }) {
   return new Promise((done, reject) => {
     const runtimeRoot = join(root, 'web-service')
     const helper = spawn(join(runtimeRoot, 'node'), [join(runtimeRoot, 'bin', 'desktop-service-sync.mjs')], {
@@ -27,6 +27,6 @@ function serviceCommand({ home, port, root, fixture, environment, onProgress = (
     helper.once('error', reject)
     helper.once('exit', code => code === 0 && result ? done(result) : reject(Object.assign(new Error(failure || (action==='stop'?'后台服务停止未完成':'本机 Web 同步未完成,请重试')), { code: failureCode })))
     helper.stdin.on('error', () => {})
-    helper.stdin.end(JSON.stringify({ home, port, runtimeRoot, fixture, environment, action }))
+    helper.stdin.end(JSON.stringify({ home, port, runtimeRoot, fixture, environment, action, force }))
   })
 }

+ 37 - 2
desktop/startup-feedback.test.mjs

@@ -1,12 +1,13 @@
 import {test} from 'node:test'
 import assert from 'node:assert/strict'
-import {mkdtemp,realpath,readFile,rm,mkdir} from 'node:fs/promises'
+import {mkdtemp,realpath,readFile,rm,mkdir,cp,writeFile,readdir} from 'node:fs/promises'
 import {tmpdir} from 'node:os'
 import {join,resolve} from 'node:path'
 import {createServer} from 'node:http'
 import {createHash} from 'node:crypto'
 import {_electron as electron} from '@playwright/test'
-import {LaunchAgentService,localRequest} from '../bin/lib/service-update.mjs'
+import {LaunchAgentService,localRequest,synchronizeDesktop} from '../bin/lib/service-update.mjs'
+import {sealRuntime,verifyRuntimePackage} from '../bin/lib/runtime-release.mjs'
 
 const root=resolve(import.meta.dirname,'..')
 test('built startup page shows a real helper error and Retry recovers into the Web',{timeout:90000},async()=>{
@@ -42,3 +43,37 @@ test('built startup page shows a real helper error and Retry recovers into the W
     await driver.stop();await rm(home,{recursive:true,force:true})
   }
 })
+test('same-version unknown ancestry offers an explicit overwrite and preserves existing user data',{timeout:90000},async()=>{
+ const home=await realpath(await mkdtemp(join(tmpdir(),'yaoyao-force-overwrite-')))
+ const reservation=createServer();await new Promise(done=>reservation.listen(0,'127.0.0.1',done))
+ const port=reservation.address().port;await new Promise(done=>reservation.close(done))
+ const payload=process.env.DESKTOP_TEST_EXECUTABLE?resolve(process.env.DESKTOP_TEST_EXECUTABLE,'../../Resources/runtime/web-service'):join(root,'.desktop-build/web-service')
+ const original=verifyRuntimePackage(payload),old=join(home,'updates/old-runtime')
+ await cp(payload,old,{recursive:true})
+ await writeFile(join(old,'build-info.json'),JSON.stringify({commit:'f'.repeat(40),ancestors:[],buildNumber:1,dirty:false}))
+ sealRuntime(old)
+ const releaseRoot=join(home,'updates','fixture-releases')
+ const driver=new LaunchAgentService({home,port,releaseRoot,label:`cn.samien.yaoyao.sync-test.${createHash('sha256').update(home).digest('hex').slice(0,16)}`,plistPath:join(home,'updates','fixture-service.plist'),environment:{HERMES_YAOYAO_UPSTREAM:'http://127.0.0.1:1',HERMES_YAOYAO_SUPERVISE_DASHBOARD:'0'}})
+ let app
+ try{
+  await synchronizeDesktop({home,runtimeRoot:old,releaseRoot,driver})
+  await writeFile(join(home,'user-proof.txt'),'preserve existing user files')
+  app=await electron.launch({...(process.env.DESKTOP_TEST_EXECUTABLE?{executablePath:process.env.DESKTOP_TEST_EXECUTABLE}:{}),args:process.env.DESKTOP_TEST_EXECUTABLE?[]:[root],cwd:root,
+   env:{...process.env,HERMES_YAOYAO_DESKTOP_TEST_HOME:home,HERMES_YAOYAO_DESKTOP_PORT:String(port),HERMES_YAOYAO_DESKTOP_TEST_SYNC:'1',HERMES_YAOYAO_UPSTREAM:'http://127.0.0.1:1'},timeout:30000})
+  const page=await app.firstWindow(),button=page.getByRole('button',{name:'使用当前 App 覆盖同版本 Web',exact:true})
+  await button.waitFor({timeout:30000})
+  assert.match(await page.locator('#status').textContent(),/构建先后关系无法确定/)
+  assert.equal(verifyRuntimePackage(driver.snapshot().root).commit,'f'.repeat(40))
+  await mkdir(join(root,'test-results/desktop'),{recursive:true});await page.screenshot({path:join(root,'test-results/desktop/same-version-force.png')})
+  await button.click();await page.waitForURL(`http://127.0.0.1:${port}/**`,{timeout:45000})
+  const record=JSON.parse(await readFile(join(home,'service-instance.json'),'utf8'))
+  const identity=await localRequest(`http://127.0.0.1:${port}/desktop/service`,record.token)
+  assert.equal(identity.body.build.artifactDigest,original.artifactDigest)
+  assert.equal(await readFile(join(home,'user-proof.txt'),'utf8'),'preserve existing user files')
+  assert.equal(JSON.parse(await readFile(join(home,'updates/desktop-sync.json'),'utf8')).action,'overwrite')
+  assert.ok((await readdir(join(home,'updates/backups'))).length>=2)
+  const denied=await page.evaluate(()=>window.yaoyaoDesktop.forceSync().then(()=>false,()=>true))
+  assert.equal(denied,true,'the Web renderer cannot invoke the boot-only overwrite channel')
+  await page.screenshot({path:join(root,'test-results/desktop/same-version-recovered.png')})
+ }finally{await app?.close().catch(()=>{});await driver.stop();await rm(home,{recursive:true,force:true})}
+})

+ 1 - 1
docker.env.example

@@ -3,7 +3,7 @@ HERMES_YAOYAO_BIND_ADDRESS=127.0.0.1
 HERMES_YAOYAO_PUBLISHED_PORT=15300
 # 远程通用镜像支持 AMD64 / ARM64;每次发布更新 latest 并保留旧版本标签。
 # HERMES_YAOYAO_IMAGE=samienluo/yaoyao:latest
-# 固定版本:samienluo/yaoyao:v0.4.18;仅 AMD64:samienluo/yaoyao:v0.4.18-amd。
+# 固定版本:samienluo/yaoyao:v0.4.19;仅 AMD64:samienluo/yaoyao:v0.4.19-amd。
 # 留空时使用本地构建名称 yaoyao:local。
 # YAOYAO_DESKTOP_IMAGE=hermes-yaoyao-desktop:0.4.0
 # Cursor Universal 兼容桌面的本地构建名称;基础镜像在 deploy/computer/Dockerfile.cursor 中固定。

+ 11 - 1
docs/app-web-sync.md

@@ -10,12 +10,20 @@
 | 版本较旧,或同版本且提交是 App 构建的祖先 | 等待空闲后向上同步 |
 | 同一构建/同一干净提交 | 直接连接 |
 | 发布版本或同版本提交更新 | 保留当前 Web |
-| 同版本分支关系不明、无法识别的工作区快照 | 保留服务并说明无法自动判断 |
+| 同版本分支关系不明、无法识别的工作区快照 | 启动页提供“使用当前 App 覆盖同版本 Web”,由用户明确选择 |
 
 `build-info.json` 包含提交、构建序号、祖先提交、工作区状态和构建时间;构建序号仅用于展示,提交的先后必须有祖先关系,不能比较哈希字典序或文件时间。`runtime-manifest.json` 对完整服务包逐文件计算 SHA-256,并拒绝额外文件、丢失文件和符号链接。App 内置 Node 保持原签名,避免签名后改变已封存的服务包。许可证位于 `web-service/NODE-LICENSE.txt`。
 
 成功后在数据目录的 `updates/desktop-sync.json` 记录本次 App 服务包校验值。再次打开同一构建不会重新同步,允许 Web 继续自行升级或经兼容性检查后单独回滚。该记录属于数据目录,不是全局 App 偏好。失败不写成功记录,启动页可重试。
 
+## 强制覆盖同版本 Web
+
+App 与 Web 的版本号相同,即使提交来自不同历史或属于工作区快照,也可以使用当前 App 的配套服务覆盖。启动页遇到构建关系不明时显示 **使用当前 App 覆盖同版本 Web**;进入 Web 后也可从 macOS 的 **夭夭** 菜单选择同名操作。
+
+覆盖是一次性的明确操作:它跳过构建先后判定和旧的同步成功记录,使用当前 App 自带的完整服务包。仍须校验安装包、服务归属和空闲状态,保留聊天、设置、文件及已有服务配置,并先备份;失败自动恢复。服务忙碌时延后覆盖,不中断进行中的任务。后续普通启动恢复自动同步规则,不持续强制覆盖。不同版本号不使用此入口,升级或回退沿用原有流程。
+
+同步助手通过 `force: true` 传递此选择;只有受信任的原生启动页和 App 菜单可以触发,Web 页面及其他窗口不能调用覆盖 IPC。`service_build_unknown` 仅表示可人工处理的同版本构建冲突,包损坏、权限或身份错误不会提供强制入口。
+
 ## 统一后台服务
 
 App 同步和 Web 的更新/回滚共用 `bin/lib/service-update.mjs` 的事务、发布目录、SQLite 更新互斥和原有 `active.lock`。App 同步使用包内服务,不下载或现场运行 npm 构建;Web 的更新入口仍按发布源准备新版本。两条路径都切换同一个 `current`。
@@ -51,4 +59,6 @@ App 同步和 Web 的更新/回滚共用 `bin/lib/service-update.mjs` 的事务
 
 启动页的 HTML、JavaScript、CSS 与 preload 都是必需打包资源,构建时逐一核验。`desktop/startup-feedback.test.mjs` 在真实 App 中制造同步助手失败,确认错误文本与“重试 / 查看日志”可见,再解除测试阻塞并点击重试进入 Web。只有 `service_busy` 会允许连接已验证的原服务;包校验、身份核对及其他错误继续显示在启动页。
 
+2026-09-14 验证:25 项桌面测试及 23 项同步/服务实例/更新接口测试通过。新增真实 App 流程先安装同版本但无共同提交历史的服务,验证启动页明确提供覆盖入口,点击后构建切换成功、原文件和备份保留;Web 页面不能调用覆盖 IPC。另覆盖旧同步记录、忙碌服务、损坏包、跨版本拒绝及覆盖失败的数据恢复。
+
 2026-09-09 验证:类型检查和生产/桌面构建通过;全量测试 787 项通过、6 项按环境跳过。原有 8 项桌面测试通过,新增真实 App/LaunchAgent 同步流程通过,覆盖退出后服务保留、较新 Web 保留、旧配置保留以及服务停止后再次打开 App 恢复独立服务。开发签名 App 的严格签名、服务包完整性及实际同步流程均已验证。此次修改不包含替换本机已安装 App 或正式 Web 服务。

+ 7 - 7
docs/docker-install.md

@@ -12,14 +12,14 @@
 
 | 标签 | 架构 |
 | --- | --- |
-| `v0.4.18-amd` | `linux/amd64` |
-| `v0.4.18` | `linux/amd64`、`linux/arm64`,拉取时自动匹配 |
-| `latest` | 最新稳定通用镜像,当前指向与 `v0.4.18` 相同的镜像 |
+| `v0.4.19-amd` | `linux/amd64` |
+| `v0.4.19` | `linux/amd64`、`linux/arm64`,拉取时自动匹配 |
+| `latest` | 最新稳定通用镜像,当前指向与 `v0.4.19` 相同的镜像 |
 
 ```sh
-docker pull samienluo/yaoyao:v0.4.18
+docker pull samienluo/yaoyao:v0.4.19
 # 需要固定 AMD64 时:
-docker pull samienluo/yaoyao:v0.4.18-amd
+docker pull samienluo/yaoyao:v0.4.19-amd
 ```
 
 每次新版本发布都会更新 `latest`,旧版本标签继续保留。需要固定部署版本时使用具体版本标签。
@@ -34,7 +34,7 @@ cp docker.env.example docker.env
 
 | 配置 | 用途 |
 | --- | --- |
-| `HERMES_YAOYAO_IMAGE` | 远程镜像可设为 `samienluo/yaoyao:v0.4.18` 或 `samienluo/yaoyao:latest`;未设置时使用本地构建名称 |
+| `HERMES_YAOYAO_IMAGE` | 远程镜像可设为 `samienluo/yaoyao:v0.4.19` 或 `samienluo/yaoyao:latest`;未设置时使用本地构建名称 |
 | `HERMES_YAOYAO_UPSTREAM` | Hermes 上游地址,默认 `http://host.docker.internal:9119` |
 | `HERMES_YAOYAO_BIND_ADDRESS` | Web 的宿主机发布地址,默认 `127.0.0.1`;局域网访问可设为 `0.0.0.0` |
 | `HERMES_YAOYAO_PUBLISHED_PORT` | 宿主机 Web 端口,默认 `15300` |
@@ -152,7 +152,7 @@ curl --fail http://127.0.0.1:15300/healthz
 使用 Docker Hub 发布镜像时,在 `docker.env` 设置:
 
 ```dotenv
-HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.18
+HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.19
 YAOYAO_CURSOR_DESKTOP_IMAGE=samienluo/yaoyao-desktop:v0.4.12-cursor-amd
 ```
 

+ 1 - 1
docs/github-updates.md

@@ -16,7 +16,7 @@ macOS 独立 Web 继续使用现有升级事务:构建新版本、等待任务
 
 新版提供当前架构的 `Yaoyao-{版本}-{架构}.dmg` 和 `SHA256SUMS.txt` 后,窗口显示下载按钮。下载可取消或重试,不会停止聊天、Runner 或后台服务。文件写入 Web 数据目录下的 `updates/desktop-downloads`,通过大小、SHA-256 和 DMG 完整性检查后才提供“打开安装包”。GitHub 附件摘要存在时也必须一致,缓存重新使用和打开前会核对文件。
 
-打开 DMG 后手动拖入“应用程序”安装。不会自动覆盖正在运行的 App、申请提权或自动重启;开发签名包尚未公证,请遵循 macOS 提示。安装后首次启动仍只向上同步较旧的本机 Web,保留较新的独立服务。
+打开 DMG 后手动拖入“应用程序”安装。不会自动覆盖正在运行的 App、申请提权或自动重启;开发签名包尚未公证,请遵循 macOS 提示。安装后首次启动自动同步较旧的本机 Web,保留较新的独立服务。同版本构建关系不明时,可在启动页或夭夭菜单选择“使用当前 App 覆盖同版本 Web”,详见 [同步与覆盖规则](app-web-sync.md)。
 
 下载和打开接口只授权给本地更新窗口,远程页面、普通聊天页面和启动页不能调用。发布说明按纯文本显示,不执行远端 HTML 或脚本。
 

+ 16 - 1
docs/local-vm.md

@@ -17,7 +17,22 @@
 
 ## 同一 Bot 使用本机和虚拟机
 
-Web/桌面端的 Bot 电脑面板在选择 **本地虚拟机** 或 **云端 · Grok Bot** 后显示独立的 **允许本机环境** 复选框。勾选不会改变所选虚拟机类型;切换到自动、本机、仅浏览器或不使用电脑时自动清除该选项,切回虚拟机也不会重新勾选。
+选择本地虚拟机后,电脑面板提供独立的 **执行方式**:
+
+- **虚拟机模式**:保留原有独立 Worker。可选的“允许本机环境”继续提供本机文件、命令与复制工具。
+- **本机协作模式**:复用云端电脑使用的原生 Profile 会话和工具桥,保留基础 Profile 的本机工具、配置和上下文,同时加入本地虚拟机工具。`computer_*` 在虚拟机中执行,本机操作使用 Profile 已授权的原生工具;`computer_copy_file` 显式复制两个环境的文件,`computer_export` 回传虚拟机产物。此模式本身包含本机环境能力,不再显示重复的权限复选框。
+
+执行方式按 Bot 保存,旧记录默认使用虚拟机模式,不自动迁移。切换执行方式后创建对应的新执行会话,并携带近期聊天记录;虚拟机工作目录、镜像和共享成员不变。任务或人工接管期间不能切换。Bot 创建的成员、临时助手不继承本机协作模式;切换到其他电脑类型或返回虚拟机模式时清除本机协作授权。
+
+本机协作模式需要支持 `profile-computer-v1` 的配套 Runner,以及当前 Profile 已启用的 `yaoyao-bot-bridge`。使用与云端模式相同的原生工具桥绑定,不启动隔离模型 Worker。人工接管会请求原生 Profile 停止,确认其空闲且在途虚拟机操作结束后才转交控制权;交还后在原 Profile 会话继续。会话压缩产生的新存储编号在 Runner 中保存,重连继续读取正确的 Profile 历史。
+
+Compose 部署同样可为已选择的桌面启用本机协作模式,仍由 Compose 管理桌面数量和生命周期。所有模式沿用原有虚拟机网络策略,不增加网站发布或端口转发。
+
+兼容旧客户端:取消“允许本机环境”会同时退出本机协作模式,恢复虚拟机模式;不会忽略撤销请求。`PUT /api/app/agents/:id/computer-selection` 新增可选 `vmExecution: worker | profile`,未传入时保留原选择。显式同时提交 `profile` 和 `allowHostEnvironment: false` 会拒绝冲突配置。
+
+2026-09-14 验证:1119 项服务端及客户端回归通过;新增模式、旧模式本机选项、云端本机选项共 3 项浏览器流程通过(含浅色桌面、深色 390px 页面及刷新恢复)。独立临时 Hermes 配置和真实 Docker 桌面验证了原生终端、虚拟机命令、虚拟机文件读取、Profile 项目上下文与完整回复。模型响应由确定性的本机测试服务提供,不依赖外部模型;测试不使用用户会话。协议测试另覆盖会话编号更新、跨模式会话拒绝、文件复制、团队工具、接管等待与交还继续。
+
+Web/桌面端的 Bot 电脑面板在选择 **本地虚拟机的虚拟机模式** 或 **云端 · Grok Bot** 后显示独立的 **允许本机环境** 复选框。勾选不会改变所选虚拟机类型;切换到自动、本机、仅浏览器或不使用电脑时自动清除该选项,切回虚拟机也不会重新勾选。
 
 - 本地虚拟机勾选后,`host_shell`、`host_read_file`、`host_write_file` 在 **Hermes 执行节点所在主机**运行,可操作该主机用户有权访问的文件和程序。默认本机工作目录采用 Profile 的显式目录;`.`、`auto`、`cwd` 使用执行节点用户的主目录。
 - `computer_shell`、`computer_read_file`、`computer_write_file`、桌面操作等继续在隔离 Linux 环境内执行。虚拟机不会因为启用双环境而挂载本机项目目录。

+ 1 - 1
docs/macos-app.md

@@ -24,7 +24,7 @@ App 新增“检查 App 更新…”窗口,直接从官方 GitHub 检查稳定
 正式 App 的同步在安装/更新后的**首次启动**执行;复制 App 文件本身不执行服务操作。详见 [App 与 Web 版本同步](app-web-sync.md)。
 
 - 同步仅针对当前用户、相同数据目录和端口的本机 LaunchAgent;保留已有服务的地址、TLS、上游及通知配置。
-- 使用版本、提交关系和完整服务包校验值识别构建。同版本不同提交可以向上同步;不同分支且无法确认先后时保留现有服务并提示原因。
+- 使用版本、提交关系和完整服务包校验值识别构建。同版本不同提交可以向上同步;无法确认先后时,启动页提供“使用当前 App 覆盖同版本 Web”。也可从夭夭菜单执行,保留数据、先备份,服务忙碌时不切换。
 - App 携带独立 Node 运行时及预编译 Web 服务,首次同步不依赖联网、npm 或源码构建。Node 的许可证随服务包交付。
 - 同步成功按 App 服务包校验值记账;同一构建再次打开不会反复覆盖 Web。Web 可以继续通过原有更新入口升级。
 - 新版服务空闲时短暂暂停请求,停止后备份数据、切换版本,验证实际构建、健康及关键接口后开放请求。失败恢复程序与数据;进程中断由下一次同步或更新恢复。

+ 49 - 0
docs/releases/v0.4.19.md

@@ -0,0 +1,49 @@
+# 夭夭 AI v0.4.19
+
+本次发布 Web、macOS Apple Silicon 桌面版、Android 1.3(171)及 Docker Web 双架构镜像。
+
+## 更新内容
+
+- 普通聊天正式使用服务端统一消息协议 v2。流式输出、历史恢复和上游消息编号变化时保持稳定的显示身份,明确区分输入、回合、正文片段与工具调用,减少重复消息和内容覆盖。
+- 消息、事件收据与重放日志在同一事务中保存。断线后从已保存位置继续,发现事件缺口或会话代次变化时重新同步;分页不会覆盖更新的消息或恢复已经删除的记录,保存失败不推进恢复位置。
+- 修复普通聊天发送前本地缓存写入失败,以及刷新后未恢复运行和待处理交互状态的问题。缓存保存独立快照,恢复检查点时同步还原界面状态。
+- 已有普通聊天记录通过后台队列核验,运行中的会话延后处理。切换前保留历史、消息及关联记录的存档;无法确认归属的已接收输入保留并等待核验,不按文本相同删除消息。
+- 本地虚拟机新增“本机协作模式”,在已有本机会话和授权工具的基础上加入虚拟机操作,支持显式复制文件与回传产物。旧记录仍使用原虚拟机模式,任务或人工接管期间不能切换,临时助手和新成员不自动继承该模式。
+- 修复执行节点协作模式能力握手被过滤的问题,配套节点可正确显示和启用本机协作能力。
+- 桌面启动页和应用菜单新增“使用当前 App 覆盖同版本 Web”。需要用户主动选择,执行前校验完整性、归属与空闲状态并备份,失败时恢复;忙碌时延后,不中断当前任务。
+- Android 1.3(171)同步接入普通聊天 v2,持久保存消息与恢复检查点,并保留待确认输入。
+
+## 升级要求
+
+**普通聊天存在协议兼容性变更,请将服务端和客户端配套升级。**
+
+- Web/macOS 使用 v0.4.19,Android 使用 1.3(171)。其他移动端也必须具备 v2 支持;旧客户端普通聊天会收到升级提示,新客户端不再回退到旧消息协议。升级服务端前请确认所使用的客户端均已支持 v2。
+- v2 是正式代码路径,v1 试验开关不再控制普通聊天。Bot 模式及原生机器人通道保持各自原有协议边界。
+- 升级前备份 `.yaoyao` 数据与密钥。旧数据核验将在新服务启动后后台执行;需要回退时使用配套备份恢复流程,避免直接让旧程序读取升级后的数据。
+- 本机协作模式需要更新配套执行节点,并在基础会话中启用所需工具桥。固定桌面的数量和生命周期继续由原部署配置管理。
+- 主项目采用 Apache-2.0,第三方组件保留各自许可与署名。
+
+## 下载
+
+- `Yaoyao-0.4.19-arm64.dmg`:macOS Apple Silicon,Apple Development 开发签名,未公证。
+- `Yaoyao-1.3-171-android.apk`:Android 12 及以上,正式签名。源码提交 `3c65d94`。
+- `Yaoyao-0.4.19-source.tar.gz`:Web/桌面源码及部署配置。
+- `SHA256SUMS.txt`:以上附件的 SHA-256 校验值。
+
+## Docker Hub
+
+| 镜像 | 架构 |
+| --- | --- |
+| `samienluo/yaoyao:v0.4.19-amd` | `linux/amd64` |
+| `samienluo/yaoyao:v0.4.19` | `linux/amd64`、`linux/arm64` |
+| `samienluo/yaoyao:latest` | 版本镜像验证后指向同一通用镜像 |
+
+```sh
+docker pull samienluo/yaoyao:v0.4.19
+docker compose --env-file docker.env pull web
+docker compose --env-file docker.env up -d --no-build web
+```
+
+Compose 中设置 `HERMES_YAOYAO_IMAGE=samienluo/yaoyao:v0.4.19`。独立电脑镜像沿用现有配置,保留旧版本标签与附件。Docker 镜像发布到 Docker Hub,GitHub 不上传镜像归档。
+
+最终附件摘要、镜像摘要和运行验证记录发布在 [GitHub 发布页](https://github.com/Lsamien/yaoyao/releases/tag/v0.4.19)。模拟器和协议测试不能替代实体设备后台挂起及蜂窝/Wi-Fi 切换验收,这些真机场景尚未完成验证。

+ 75 - 0
docs/verification/2026-09-14-ordinary-chat-v2/README.md

@@ -0,0 +1,75 @@
+# 普通聊天 v2 统一消息链路
+
+实现范围为普通聊天。Web/macOS、iOS、Android 同时使用 `ordinary-chat-transcript-v2`;原生 Hermes Bot 和 Bot 模式保留原来的运行边界。本次只交付源码和验证,未发布、部署或安装正式客户端,也没有操作实际聊天数据库。
+
+## 服务端职责
+
+`ChatTranscriptStore` 直接消费经过规范化的输入回执、运行事件和恢复快照,持久化回合、消息、片段归属及上游别名。`chat_messages` 仅保留上游历史导入和核验职责;旧的 `chatEventProjection.ts` 与实时写入旧缓存的路径已移除。
+
+- 显示 ID 在流式输出、恢复、上游数据库 ID 出现后保持不变。回合、消息、工具调用分别建立身份关系。
+- 增量追加,完整快照替换所属片段;预览后的完成事件结束同一条消息。工具调用、明确的新消息边界和后续片段保留各自的正文。
+- 排队输入不会改变当前输出的归属,steer 保持在当前回合。迟到的命令回执或旧回合完成事件不会重新开启、结束当前运行。
+- 事件收据、源游标、规范记录和 SSE 日志在同一 SQLite 事务提交。上游事件 ID 使用上游 epoch、运行路由和序号,服务端进程重启不改变已保存收据的身份。
+- 无法取得连续上游重放时,保留当前记录并接收完整恢复快照,暂不追加无法确定位置的增量;终态和后台历史核验补齐内容。
+- 列表、附件来源及最终回复未读数从规范记录读取。历史核验不重新提交问题、不重发历史完成通知。流式热路径不再扫描整份聊天正文。
+
+## v2 契约与客户端
+
+沿用 `/api/app/chat/sessions/:id/snapshot` 和 `/events`。消息包含稳定 `id`、服务端顺序 `seq`、`revision`、`turn_id`、`segment_kind`,用户输入另有 `client_message_id`。上游 ID 只作为关联元数据。
+
+快照包含会话 epoch、游标、消息覆盖、删除 ID、运行/排队状态和待处理交互。每个事件包含 epoch、cursor、previousCursor、total;previousCursor 检测同一会话漏掉的事件,无须假设全局 SQLite cursor 连续。
+
+三端仅从规范记录生成普通聊天正文。运行路由的 resume 不再直接插入 assistant,旧历史拼接不再进入普通聊天路径。客户端保留独立的待确认输入,通过 client_message_id 消除本地输入与服务端回显的双份表示。
+
+消息、删除标记和 checkpoint 一起保存,保存失败不推进消费者游标;重复版本不再次应用。旧分页返回不能覆盖新版本或恢复已删除消息,分页不确认 SSE 游标。会话代次变化时替换已确认窗口并保留本地待发送输入。前台恢复重新订阅已保存位置,事件连接使用 45 秒无数据超时。
+
+新客户端不接受 v1 checkpoint,不回退到旧消息生成路径。新服务器对缺少 v2 声明的普通聊天通道返回 426 升级提示;原生 Bot 通道不受此门禁影响。v1 的试验环境变量不再控制这条正式代码路径。
+
+## 已有数据的核验修复
+
+启动时登记旧的已拥有会话,使用现有持久化后台队列核验,最多两个会话并发。运行中的会话延后,读取期间版本发生变化则重试。
+
+原始历史和规范记录、别名在切换前存入 `chat_transcript_archives`;修复任务保留状态,可中断后继续。结构变化产生新的会话 epoch,使三端用一个新快照替换旧窗口。无法确认的已接收输入及其关联回合保留,等待后续核验,不根据文本相同删除消息。用户真正重复发送的消息保持独立。
+
+实际旧数据的修复将在部署新服务后后台执行,本次验证仅使用临时 SQLite。
+
+## 验证
+
+- Web/服务端:全量 Vitest 1172 项通过、19 项按原配置跳过,`npm run typecheck`、`npm run build` 通过。
+- 服务端使用隔离事件驱动真实 HTTP/SSE 接口验证:事件重放结果与终态快照完全一致;预览和完成仅产生一个显示消息;旧普通聊天通道收到升级响应。
+- 场景覆盖:预览重复、ID 变化、保存失败、源游标重启、缺失重放、迟到事件、队列拒绝、steer、附件、删除与分页交错、旧 epoch、旧缓存升级以及会话切换。
+- Web、Swift、Kotlin 使用相同 JSON 协议输入;执行 `python3 docs/verification/2026-09-14-ordinary-chat-v2/verify-fixtures.py` 校验三份语义一致。规范化 SHA-256:`4512ac92a07783cd49f23949830c7c7e6fe94e96ce3164fa0a9b63760fdf6dbc`。
+- Android:`:core:model:test` 54 项、`:core:network:test` 46 项通过;`:app:compileDebugKotlin` 通过。
+- iOS 模拟器:ChatHistoryStore、ChatRuntime、HermesHTTPRealtime、OrdinaryTranscriptV2 共 355 项通过,包括将旧回复替换为规范记录、保留待确认输入并按身份合并回显。
+
+较大范围 iOS 检查还发现两个文件库已有失败:`testMessageFileArchiveQueryUsesContextAndReturnsCacheState`、`testYaoyaoFileLibraryUsesSupportedPluginQueryAndDecodesArchive`。在独立的未修改 `3dc20b6` 源码副本中,两项测试以同样的 URLProtocol transport 错误失败;这两个失败未混入本次修复。
+
+实体 iPhone 当前不可用。模拟器与协议重放验证不代表实体设备的后台挂起、蜂窝/Wi-Fi 切换已经验收;正式发布前还需在实体设备完成这部分验证。
+
+## 复验命令
+
+在 yaoyao:
+
+```sh
+NODE_OPTIONS=--no-experimental-webstorage npm test
+npm run typecheck
+npm run build
+python3 docs/verification/2026-09-14-ordinary-chat-v2/verify-fixtures.py
+```
+
+在 yaoyao-android(使用本机 JDK 17):
+
+```sh
+JAVA_HOME=/Users/samien/.local/share/hermes-android-toolchain/jdk-17 ./gradlew :core:model:test :core:network:test :app:compileDebugKotlin
+```
+
+在 yaoyao-mobile(将 destination 替换为可用模拟器):
+
+```sh
+xcodebuild -project YaoYaoAI.xcodeproj -scheme YaoYaoAI \
+  -destination 'platform=iOS Simulator,id=2AB1845D-8B54-4828-BA6E-0538CD08D488' \
+  test -only-testing:YaoYaoAITests/ChatRuntimeTests \
+  -only-testing:YaoYaoAITests/ChatHistoryStoreTests \
+  -only-testing:YaoYaoAITests/HermesHTTPRealtimeTests \
+  -only-testing:YaoYaoAITests/OrdinaryTranscriptV2Tests CODE_SIGNING_ALLOWED=NO
+```

+ 17 - 0
docs/verification/2026-09-14-ordinary-chat-v2/verify-fixtures.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+"""Verify that TypeScript, Swift and Kotlin exercise the same v2 wire contract."""
+import hashlib
+import json
+from pathlib import Path
+import re
+
+root = Path(__file__).resolve().parents[3]
+source = json.loads((root / 'tests/fixtures/ordinary-chat-v2/protocol.json').read_text())
+android = json.loads((root.parent / 'yaoyao-android/core/network/src/test/resources/ordinary-chat-v2/protocol.json').read_text())
+ios_test = (root.parent / 'yaoyao-mobile/YaoYaoAITests/HermesHTTPRealtimeTests.swift').read_text()
+match = re.search(r'fixtureJSON = #"""\s*(.*?)\s*"""#', ios_test, re.S)
+assert match, 'iOS wire fixture is missing'
+ios = json.loads(match.group(1))
+assert source == android == ios, 'The three client fixtures have diverged'
+canonical = json.dumps(source, sort_keys=True, ensure_ascii=False, separators=(',', ':')).encode()
+print('Three-client fixture SHA-256:', hashlib.sha256(canonical).hexdigest())

+ 2 - 2
package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "yaoyao",
-  "version": "0.4.18",
+  "version": "0.4.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "yaoyao",
-      "version": "0.4.18",
+      "version": "0.4.19",
       "license": "Apache-2.0",
       "dependencies": {
         "@koa/bodyparser": "^5.0.0",

+ 1 - 1
package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaoyao",
-  "version": "0.4.18",
+  "version": "0.4.19",
   "private": true,
   "license": "Apache-2.0",
   "description": "夭夭 AI:聊天、多 Agent 团队、文件库与电脑工作空间",

+ 3 - 3
release.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "releaseVersion": "0.4.18",
-  "webVersion": "0.4.18",
-  "gitTag": "v0.4.18"
+  "releaseVersion": "0.4.19",
+  "webVersion": "0.4.19",
+  "gitTag": "v0.4.19"
 }

+ 235 - 80
src/client/api/chatTranscript.ts

@@ -1,98 +1,253 @@
 import { apiRequest } from './client'
 import { SSEParser } from '@shared/sse'
-import { applyTranscriptEvent, CHAT_TRANSCRIPT_FEATURE, TranscriptGap,
-  type TranscriptEvent, type TranscriptMessage, type TranscriptSnapshot } from '@shared/chatTranscript'
+import {
+  applyTranscriptEvent,
+  CHAT_TRANSCRIPT_FEATURE,
+  TranscriptGap,
+  type TranscriptEvent,
+  type TranscriptMessage,
+  type TranscriptSnapshot,
+} from '@shared/chatTranscript'
 
+/** Serial, durable replica: no state/cursor becomes visible before changed commits it. */
 export class ChatTranscriptClient {
   private abort = new AbortController()
-  private messages: TranscriptMessage[] = []
-  private cursor = 0
-  private epoch = ''
   private snapshot?: TranscriptSnapshot
   private fetchingOlder = false
-  constructor(readonly profile:string,readonly sessionId:string,
-    readonly changed:(snapshot:TranscriptSnapshot)=>Promise<void>,readonly failed:(error:Error)=>void,
-    readonly initialCount=150){}
-  static async supported():Promise<boolean>{
-    try{return (await apiRequest<{features:string[]}>('/api/app/chat/capabilities')).features.includes(CHAT_TRANSCRIPT_FEATURE)}catch{return false}
+  private operations: Promise<unknown> = Promise.resolve()
+  private request?: AbortController
+  private readonly foreground = () => {
+    if (document.visibilityState === 'visible') this.request?.abort()
   }
-  close(){this.abort.abort()}
-  restore(value:TranscriptSnapshot){if(value.profile===this.profile&&value.sessionId===this.sessionId){this.snapshot=value;this.messages=value.messages;this.cursor=value.cursor;this.epoch=value.epoch}}
-  private path(suffix:string,query:Record<string,string>={}) {return `/api/app/chat/sessions/${encodeURIComponent(this.sessionId)}/${suffix}?${new URLSearchParams({profile:this.profile,...query})}`}
-  private async page(before?:number):Promise<TranscriptSnapshot>{
-    const value=await apiRequest<TranscriptSnapshot>(this.path('snapshot',{limit:'150',...(before===undefined?{}:{before:String(before)})}),{signal:this.abort.signal})
-    if(value.protocol!==CHAT_TRANSCRIPT_FEATURE||value.profile!==this.profile||value.sessionId!==this.sessionId)throw new TranscriptGap()
+  constructor(
+    readonly profile: string,
+    readonly sessionId: string,
+    readonly changed: (snapshot: TranscriptSnapshot) => Promise<void>,
+    readonly failed: (error: Error) => void,
+    readonly initialCount = 150,
+  ) {
+    if (typeof document !== 'undefined') document.addEventListener('visibilitychange', this.foreground)
+  }
+  static async supported(): Promise<boolean> {
+    return (await apiRequest<{ features: string[] }>('/api/app/chat/capabilities')).features.includes(
+      CHAT_TRANSCRIPT_FEATURE,
+    )
+  }
+  close() {
+    this.abort.abort()
+    this.request?.abort()
+    if (typeof document !== 'undefined') document.removeEventListener('visibilitychange', this.foreground)
+  }
+  restore(value: TranscriptSnapshot) {
+    if (
+      value.protocol === CHAT_TRANSCRIPT_FEATURE &&
+      value.profile === this.profile &&
+      value.sessionId === this.sessionId
+    )
+      this.snapshot = value
+  }
+  private serial<T>(operation: () => Promise<T>): Promise<T> {
+    const task = this.operations.then(operation, operation)
+    this.operations = task.catch(() => {})
+    return task
+  }
+  private path(suffix: string, query: Record<string, string> = {}) {
+    return `/api/app/chat/sessions/${encodeURIComponent(this.sessionId)}/${suffix}?${new URLSearchParams({ profile: this.profile, ...query })}`
+  }
+  private async page(before?: number): Promise<TranscriptSnapshot> {
+    const value = await apiRequest<TranscriptSnapshot>(
+      this.path('snapshot', { limit: '150', ...(before === undefined ? {} : { before: String(before) }) }),
+      { signal: this.abort.signal },
+    )
+    if (
+      value.protocol !== CHAT_TRANSCRIPT_FEATURE ||
+      value.profile !== this.profile ||
+      value.sessionId !== this.sessionId
+    )
+      throw new TranscriptGap()
     return value
   }
-  private async publish(){if(this.snapshot&&!this.abort.signal.aborted)await this.changed({...this.snapshot,messages:this.messages,cursor:this.cursor,epoch:this.epoch})}
-  private async hydrate(){
-    const page=await this.page()
-    if(this.abort.signal.aborted)return
-    const first=page.messages[0]?.seq??Infinity,deleted=new Set(page.deletedIds??[])
-    const old=this.epoch===page.epoch?this.messages.filter(m=>m.seq<first&&!deleted.has(m.id)):[]
-    this.messages=[...old,...page.messages];this.epoch=page.epoch;this.cursor=page.cursor;this.snapshot=page
-    // Upgrade already loaded legacy pages before replacing the visible cache.
-    while(this.messages.length<this.initialCount&&this.snapshot.hasOlder&&this.messages.length){
-      const older=await this.page(this.messages[0]!.seq)
-      if(older.epoch!==this.epoch)throw new TranscriptGap()
-      const ids=new Set(this.messages.map(m=>m.id))
-      const added=older.messages.filter(m=>!ids.has(m.id))
-      this.messages=[...added,...this.messages];this.snapshot.hasOlder=older.hasOlder
-      if(!added.length)break
+  private async commit(value: TranscriptSnapshot) {
+    if (this.abort.signal.aborted) return
+    await this.changed(value)
+    if (!this.abort.signal.aborted) this.snapshot = value
+  }
+  private merge(current: TranscriptSnapshot, page: TranscriptSnapshot): TranscriptMessage[] {
+    const deleted = new Set([...(current.deletedIds ?? []), ...(page.deletedIds ?? [])])
+    const messages = new Map(current.messages.filter((m) => !deleted.has(m.id)).map((m) => [m.id, m]))
+    for (const message of page.messages)
+      if (!deleted.has(message.id) && (messages.get(message.id)?.revision ?? 0) < message.revision)
+        messages.set(message.id, message)
+    return [...messages.values()].sort((a, b) => a.seq - b.seq || a.id.localeCompare(b.id))
+  }
+  private async hydrate() {
+    let value = await this.page()
+    if (this.abort.signal.aborted) return
+    while (value.messages.length < this.initialCount && value.hasOlder && value.messages.length) {
+      const older = await this.page(value.messages[0]!.seq)
+      if (older.epoch !== value.epoch) throw new TranscriptGap()
+      const messages = this.merge(value, older),
+        added = messages.length - value.messages.length
+      value = {
+        ...value,
+        messages,
+        hasOlder: older.hasOlder,
+        deletedIds: [...new Set([...(value.deletedIds ?? []), ...(older.deletedIds ?? [])])],
+      }
+      if (!added) break
+    }
+    await this.serial(async () => {
+      const old = this.snapshot
+      if (old?.epoch === value.epoch && old.cursor > value.cursor) return
+      // An authoritative generation replaces the covered window. Older loaded
+      // pages can be retained only inside the same epoch and outside that window.
+      if (old?.epoch === value.epoch && value.messages.length) {
+        const first = value.messages[0]!.seq
+        value = {
+          ...value,
+          messages: this.merge({ ...old, messages: old.messages.filter((m) => m.seq < first) }, value),
+        }
+      }
+      await this.commit(value)
+    })
+  }
+  async loadOlder() {
+    const starting = this.snapshot
+    if (this.fetchingOlder || !starting?.hasOlder || !starting.messages.length) return
+    this.fetchingOlder = true
+    try {
+      const page = await this.page(starting.messages[0]!.seq)
+      await this.serial(async () => {
+        const current = this.snapshot
+        if (!current || page.epoch !== current.epoch) return
+        await this.commit({
+          ...current,
+          messages: this.merge(current, page),
+          hasOlder: page.hasOlder,
+          deletedIds: [...new Set([...(current.deletedIds ?? []), ...(page.deletedIds ?? [])])],
+        })
+      })
+    } finally {
+      this.fetchingOlder = false
     }
-    await this.publish()
   }
-  async loadOlder(){
-    if(this.fetchingOlder||!this.snapshot?.hasOlder||!this.messages.length)return
-    this.fetchingOlder=true
-    try{
-      const page=await this.page(this.messages[0]!.seq)
-      if(page.epoch!==this.epoch)throw new TranscriptGap()
-      const current=new Map(this.messages.map(m=>[m.id,m]))
-      for(const message of page.messages)if((current.get(message.id)?.revision??0)<message.revision)current.set(message.id,message)
-      this.messages=[...current.values()].sort((a,b)=>a.seq-b.seq||a.id.localeCompare(b.id));this.snapshot.hasOlder=page.hasOlder
-      // A history page is not an event acknowledgement; never move cursor here.
-      await this.publish()
-    }finally{this.fetchingOlder=false}
+  private async receive(event: TranscriptEvent) {
+    await this.serial(async () => {
+      const current = this.snapshot
+      if (!current) throw new TranscriptGap()
+      if (
+        event.profile !== this.profile ||
+        event.sessionId !== this.sessionId ||
+        event.epoch !== current.epoch ||
+        !Number.isSafeInteger(event.cursor)
+      )
+        throw new TranscriptGap()
+      if (event.cursor <= current.cursor) return
+      if (
+        event.previousCursor !== current.cursor ||
+        event.type === 'session.deleted' ||
+        event.type === 'session.migrated'
+      )
+        throw new TranscriptGap()
+      const data = event.data as Record<string, any>,
+        deleted = new Set(current.deletedIds ?? [])
+      if (event.type === 'message.deleted') deleted.add(String(data.id))
+      const before = current.messages[0]?.seq
+      const unloaded =
+        ['message.patch', 'message.upsert'].includes(event.type) &&
+        typeof data.seq === 'number' &&
+        before !== undefined &&
+        data.seq < before
+      const messages =
+        unloaded || (event.type !== 'message.deleted' && deleted.has(String(data.id)))
+          ? current.messages
+          : applyTranscriptEvent(current.messages, event)
+      const next: TranscriptSnapshot = {
+        ...current,
+        messages,
+        cursor: event.cursor,
+        deletedIds: [...deleted],
+        total: event.total ?? current.total,
+      }
+      if (event.type === 'session.changed') {
+        for (const key of [
+          'running',
+          'queued',
+          'pendingApproval',
+          'pendingClarification',
+          'liveStatus',
+          'error',
+        ] as const)
+          if (data[key] !== undefined) (next as any)[key] = data[key]
+        if (data.eventType === 'session.info' && data.payload)
+          next.session = { ...next.session, ...data.payload }
+      }
+      await this.commit(next)
+    })
   }
-  async run(){
-    let needsSnapshot=!this.snapshot
-    while(!this.abort.signal.aborted){
-      let reader:ReadableStreamDefaultReader<Uint8Array>|undefined
-      try{
-        if(needsSnapshot){await this.hydrate();needsSnapshot=false}
-        const response=await fetch(this.path('events'),{headers:{Accept:'text/event-stream','Last-Event-ID':`${this.epoch}:${this.cursor}`},credentials:'include',cache:'no-store',signal:this.abort.signal})
-        if(response.status===409){needsSnapshot=true;throw new TranscriptGap()}
-        if(!response.ok||!response.body)throw new Error(`聊天消息流 HTTP ${response.status}`)
-        const parser=new SSEParser(),decoder=new TextDecoder();reader=response.body.getReader()
-        while(!this.abort.signal.aborted){
-          const {value,done}=await reader.read();if(done)break
-          for(const frame of parser.feed(decoder.decode(value,{stream:true}))){
-            if(frame.event==='reset')throw new TranscriptGap()
-            if(frame.event!=='transcript')continue
-            const event=JSON.parse(frame.data) as TranscriptEvent
-            if(event.profile!==this.profile||event.sessionId!==this.sessionId||!Number.isSafeInteger(event.cursor))throw new TranscriptGap()
-            if(event.cursor<=this.cursor)continue
-            if(event.type==='session.deleted'||event.type==='session.migrated')throw new TranscriptGap()
-            const data=event.data as {seq?:number}
-            // Older, unloaded pages are read from their current snapshot later.
-            if(!(event.type==='message.patch'&&data.seq!==undefined&&this.messages[0]&&data.seq<this.messages[0].seq))
-              this.messages=applyTranscriptEvent(this.messages,event)
-            if(this.snapshot&&event.type==='session.changed'){
-              const detail=event.data as {eventType?:string;payload?:Record<string,unknown>;running?:boolean;queued?:boolean}
-              this.snapshot.running=detail.running;this.snapshot.queued=detail.queued
-              if(detail.eventType==='session.info'&&detail.payload)this.snapshot.session={...this.snapshot.session,...detail.payload}
-            }
-            const previous=this.cursor;this.cursor=event.cursor
-            try{await this.publish()}catch(error){this.cursor=previous;throw error}
+  async run() {
+    let needsSnapshot = !this.snapshot
+    let restorePending = Boolean(this.snapshot)
+    while (!this.abort.signal.aborted) {
+      let reader: ReadableStreamDefaultReader<Uint8Array> | undefined
+      let watchdog: ReturnType<typeof setTimeout> | undefined
+      try {
+        if (restorePending) {
+          const saved = this.snapshot!
+          await this.serial(() => this.commit(saved))
+          restorePending = false
+        }
+        if (needsSnapshot) {
+          await this.hydrate()
+          needsSnapshot = false
+        }
+        if (this.abort.signal.aborted) return
+        const current = this.snapshot
+        if (!current) return
+        const attempt = new AbortController()
+        this.request = attempt
+        watchdog = setTimeout(() => attempt.abort(), 45_000)
+        const response = await fetch(this.path('events'), {
+          headers: { Accept: 'text/event-stream', 'Last-Event-ID': `${current.epoch}:${current.cursor}` },
+          credentials: 'include',
+          cache: 'no-store',
+          signal: attempt.signal,
+        })
+        if (response.status === 409) throw new TranscriptGap()
+        if (!response.ok || !response.body) throw new Error(`聊天消息流 HTTP ${response.status}`)
+        const parser = new SSEParser(),
+          decoder = new TextDecoder()
+        reader = response.body.getReader()
+        while (!this.abort.signal.aborted) {
+          clearTimeout(watchdog)
+          watchdog = setTimeout(() => attempt.abort(), 45_000)
+          const { value, done } = await reader.read()
+          if (done) break
+          for (const frame of parser.feed(decoder.decode(value, { stream: true }))) {
+            if (frame.event === 'reset') throw new TranscriptGap()
+            if (frame.event === 'transcript') await this.receive(JSON.parse(frame.data))
           }
         }
-      }catch(error){
-        if(this.abort.signal.aborted)return
-        if(error instanceof TranscriptGap)needsSnapshot=true
-        this.failed(error instanceof Error?error:new Error('聊天消息需要同步'))
-      }finally{await reader?.cancel().catch(()=>{});reader?.releaseLock()}
-      await new Promise<void>(resolve=>{const finish=()=>{clearTimeout(timer);this.abort.signal.removeEventListener('abort',finish);resolve()};const timer=setTimeout(finish,1000);this.abort.signal.addEventListener('abort',finish,{once:true});if(this.abort.signal.aborted)finish()})
+      } catch (error) {
+        if (this.abort.signal.aborted) return
+        if (error instanceof TranscriptGap) needsSnapshot = true
+        this.failed(error instanceof Error ? error : new Error('聊天消息需要同步'))
+      } finally {
+        clearTimeout(watchdog)
+        this.request = undefined
+        await reader?.cancel().catch(() => {})
+        reader?.releaseLock()
+      }
+      await new Promise<void>((resolve) => {
+        const finish = () => {
+          clearTimeout(timer)
+          this.abort.signal.removeEventListener('abort', finish)
+          resolve()
+        }
+        const timer = setTimeout(finish, 1000)
+        this.abort.signal.addEventListener('abort', finish, { once: true })
+        if (this.abort.signal.aborted) finish()
+      })
     }
   }
 }

+ 2 - 1
src/client/api/httpRealtime.ts

@@ -2,6 +2,7 @@ import type { JsonValue } from '@shared/types'
 import { SSEParser } from '@shared/sse'
 import { apiRequest, ApiError, setApiCsrfToken } from './client'
 import { createId } from '@/utils/id'
+import { CHAT_TRANSCRIPT_FEATURE } from '@shared/chatTranscript'
 
 export class HTTPRPCError extends Error {
   constructor(message: string, readonly code?: string | number, readonly data?: JsonValue) { super(message) }
@@ -26,7 +27,7 @@ export class HTTPRealtimeChannel {
     return value.features ?? []
   }
   async open(channel: 'chat' | 'groups', anchor?: { epoch: string; cursor: number }): Promise<void> {
-    const created = await apiRequest<{ id: string }>('/api/realtime/channels', { method: 'POST', body: { channel, ...anchor } })
+    const created = await apiRequest<{ id: string }>('/api/realtime/channels', { method: 'POST', body: { channel, ...(channel==='chat'?{chatProtocol:CHAT_TRANSCRIPT_FEATURE}:{}), ...anchor } })
     this.id = created.id
     if (this.stopped) { this.close(); return }
     await new Promise<void>((resolve, reject) => {

+ 3 - 1
src/client/api/realtime.ts

@@ -3,6 +3,7 @@ import type { GroupSocketEnvelope, JsonValue, RealtimeConnectionState, RpcEventF
 import { ApiError } from './client'
 import { number, record, string } from '@/utils/normalize'
 import { HTTPRealtimeChannel, HTTPRPCError } from './httpRealtime'
+import { CHAT_TRANSCRIPT_FEATURE } from '@shared/chatTranscript'
 
 export class RpcError extends Error {
   constructor(message: string, readonly code?: number | string, readonly data?: JsonValue) {
@@ -30,7 +31,8 @@ export class ChatRpcSocket {
     this.close()
     const generation = ++this.generation
     this.publishState('connecting')
-    this.transcriptSupported = (await HTTPRealtimeChannel.requireSupport()).includes('ordinary-chat-transcript-v1')
+    this.transcriptSupported = (await HTTPRealtimeChannel.requireSupport()).includes(CHAT_TRANSCRIPT_FEATURE)
+    if(!this.transcriptSupported)throw new ApiError('普通聊天需要新版服务端,请先升级服务端',426,'ordinary_chat_upgrade_required')
     if (generation !== this.generation) return
     this.http = new HTTPRealtimeChannel(frame => this.handleMessage(frame, generation), error => {
       if (generation === this.generation) this.publishState('failed', error.message)

Разлика између датотеке није приказан због своје велике величине
+ 13 - 2
src/client/components/workspace/LocalVmChatPanel.vue


+ 38 - 106
src/client/stores/chat.ts

@@ -118,6 +118,7 @@ export const useChatStore = defineStore('chat', () => {
   let persistedRecoveryPromise: Promise<void> | undefined
   const runtimePromises = new Map<string, Promise<ChatRouteState>>()
   const transcriptSupported = ref(false)
+  const outboxCache = new ScopedCache<ChatMessage[]>('ordinary-outbox-v2')
   let transcript: ChatTranscriptClient | undefined
   let transcriptGeneration = 0
 
@@ -125,17 +126,20 @@ export const useChatStore = defineStore('chat', () => {
     const generation=++transcriptGeneration
     transcript?.close();transcript=undefined
     const profile=activeProfileName.value,id=activeSessionId.value,owner=accountId()
-    if(!transcriptSupported.value||!profile||!id||id.startsWith('draft-')||sessionView==='history')return
+    if(!transcriptSupported.value||!profile||!id||id.startsWith('draft-')||sessionView==='history'||!sessions.value.some(s=>s.id===id&&s.owned===true))return
     const key=routeKey(profile,id),state=ensureRoute(profile,id),scope=cacheScope(profile)
     const current=()=>generation===transcriptGeneration&&owner===accountId()?routes[key]:undefined
     void (async()=>{
-      const cached=await historyCache.get(scope,id)
+      const [cached,outbox]=await Promise.all([historyCache.get(scope,id),outboxCache.get(scope,id)])
       if(!current())return
       if(!state.messages.length&&cached?.messages.length)state.messages=cached.messages
+      if(outbox?.length)state.messages=mergeChatMessages(state.messages,outbox)
       const client=new ChatTranscriptClient(profile,id,async value=>{
         const initial=current();if(!initial)return
         const canonical=value.messages.map(message=>{
           const mapped=normalizeChatMessage(message,id,profile)
+          const local=initial.messages.find(m=>m.role==='user'&&mapped.clientMessageId&&m.clientMessageId===mapped.clientMessageId)
+          if(!mapped.attachments?.length&&local?.attachments?.length)mapped.attachments=local.attachments
           if(message.status==='pending')mapped.stage='pending'
           return mapped
         })
@@ -143,15 +147,24 @@ export const useChatStore = defineStore('chat', () => {
         const pending=initial.messages.filter(m=>m.role==='user'&&m.stage!=='settled'&&!ids.has(m.id)&&!ids.has(m.clientMessageId))
         const messages=[...canonical,...pending]
         const {messages:_,...checkpoint}=value
-        await historyCache.set(scope,id,{messages,total:value.total,savedAt:Date.now(),transcript:checkpoint})
+        await historyCache.set(scope,id,{messages,total:value.total,savedAt:Date.now(),transcript:checkpoint},true)
         const latest=current();if(!latest)return
-        latest.messages=messages;latest.messageTotal=value.total;latest.loadedMessageCount=canonical.length
-        latest.hasMoreBefore=value.hasOlder;latest.historySynced=true;latest.isLoadingHistory=false;latest.error=undefined
+        const newerPending=latest.messages.filter(m=>m.role==='user'&&m.stage!=='settled'&&!ids.has(m.id)&&!ids.has(m.clientMessageId))
+        latest.messages=[...canonical,...newerPending];latest.messageTotal=value.total;latest.loadedMessageCount=canonical.length
+        await outboxCache.set(scope,id,newerPending,true)
+        if(current()!==latest)return
+        const approval=value.pendingApproval,clarification=value.pendingClarification
+        latest.pendingApproval=approval?{id:string(approval.request_id??approval.id),sessionId:id,message:string(approval.message??approval.prompt),toolName:string(approval.tool_name),choices:values(approval.choices).map(String),payload:approval as Record<string,JsonValue>}:undefined
+        latest.pendingClarification=clarification?{id:string(clarification.request_id??clarification.id),sessionId:id,question:string(clarification.question??clarification.prompt),payload:clarification as Record<string,JsonValue>}:undefined
+        latest.liveStatus=value.liveStatus??undefined
+        latest.hasMoreBefore=value.hasOlder;latest.historySynced=true;latest.isLoadingHistory=false;latest.error=value.error??undefined
+        const wasStreaming=latest.isStreaming
         latest.isStreaming=value.running??canonical.some(m=>m.isStreaming);latest.isQueued=value.queued??false
+        if(wasStreaming&&!latest.isStreaming)void refreshContextUsage(latest).catch(()=>{})
         if(!latest.isStreaming)latest.liveStatus=undefined
         updateInflightMarker(latest)
       },error=>{const latest=current();if(latest){latest.error=error.message;latest.historySynced=false}},Math.max(150,state.messages.length))
-      if(cached?.transcript){
+      if(cached?.transcript?.protocol==='ordinary-chat-transcript-v2'){
         const canonical=cached.messages.map(m=>m.raw as unknown as TranscriptMessage).filter(m=>m?.id&&Number.isSafeInteger(m.revision)&&Number.isSafeInteger(m.seq))
         client.restore({...cached.transcript,messages:canonical})
       }
@@ -377,17 +390,12 @@ export const useChatStore = defineStore('chat', () => {
     }
     if (!key) return
     let state = routes[key]
-    if(transcriptSupported.value&&sessionView==='chat'&&(
+    if(sessionView==='chat'&&(
       /^(message\.|tool\.|reasoning\.|thinking\.)/.test(event.type)
       || ['run.started','run.completed','run.failed','run.peer_user_message','peer.user.message'].includes(event.type))){
-      // Message bodies come exclusively from the persisted transcript stream.
-      // Legacy control events may only wake/settle the execution indicator.
-      if(['message.start','run.started'].includes(event.type))state.isStreaming=true
-      if(['message.complete','run.completed','run.failed'].includes(event.type)){
-        state.isQueued=number(payload.queue_remaining)>0;state.isStreaming=state.isQueued||number(payload.background_pending)>0
-        if(!state.isStreaming){state.liveStatus=undefined;state.pendingApproval=undefined;state.pendingClarification=undefined}
-      }
-      updateInflightMarker(state);return
+      // All ordinary message bodies and execution state come from the durable
+      // transcript. Raw upstream frames cannot create a second representation.
+      return
     }
     if (event.type === 'session.info') {
       const storedId = string(payload.stored_session_id ?? payload.storedSessionId ?? payload.session_key)
@@ -407,6 +415,7 @@ export const useChatStore = defineStore('chat', () => {
       if (!state.fastModeDirty) state.fastMode = liveFastMode
       persistFastMode(state)
     }
+    if(sessionView==='chat'&&!['session.usage','usage.update','context.update'].includes(event.type))return
     const attributedPayload = { ...payload, session_id: state.route.sessionId } as JsonValue
     const updated = applyChatEvent(state, {
       ...event, session_id: state.route.sessionId, profile: state.route.profile, payload: attributedPayload,
@@ -548,7 +557,14 @@ export const useChatStore = defineStore('chat', () => {
   }
 
   async function loadHistory(state: ChatRouteState, forceRefresh = false): Promise<void> {
-    if(transcriptSupported.value&&sessionView==='chat'){if(state===activeRouteState.value)startTranscript();return}
+    if(sessionView==='chat'&&sessions.value.some(s=>s.id===state.route.sessionId&&s.owned===true)){
+      const cached=await historyCache.get(cacheScope(state.route.profile),state.route.sessionId)
+      if(!state.messages.length&&cached?.messages.length)state.messages=cached.messages
+      await connect()
+      if(!transcriptSupported.value)throw new Error('普通聊天需要升级服务端后继续')
+      if(state===activeRouteState.value)startTranscript()
+      return
+    }
     const key = routeKey(state.route.profile, state.route.sessionId)
     const generation = ++historyLoadGeneration
     state.generation = generation
@@ -631,7 +647,7 @@ export const useChatStore = defineStore('chat', () => {
   }
 
   async function loadOlder(): Promise<void> {
-    if(transcriptSupported.value&&transcript){await transcript.loadOlder();return}
+    if(sessionView==='chat'&&activeSession.value?.owned===true){await transcript?.loadOlder();return}
     const state = activeRouteState.value
     if (!state || state.isLoadingHistory || !state.hasMoreBefore) return
     const key = routeKey(state.route.profile, state.route.sessionId)
@@ -717,82 +733,8 @@ export const useChatStore = defineStore('chat', () => {
     migrated.serverFastMode = liveFastMode
     if (!migrated.fastModeDirty && liveFastMode !== undefined) migrated.fastMode = liveFastMode
     persistFastMode(migrated)
-    const resumedMessages = values(result.messages)
-      .map(value => normalizeChatMessage(value, storedId, migrated.route.profile))
-    if (!transcriptSupported.value&&resumedMessages.length) migrated.messages = mergeChatMessages(migrated.messages, resumedMessages, 'snapshot')
-    const inflight = record(result.inflight ?? result.active_run)
-    const assistant = string(inflight.assistant)
-    const inflightError = string(inflight.error)
-    migrated.isStreaming = bool(result.running) || bool(info.running) || bool(inflight.streaming)
-    const queued = record(result.queued)
-    const queuedUser = string(queued.user)
-    migrated.isQueued = Boolean(queuedUser)
-    // A turn can be thinking or calling tools before producing any text.
-    // Create its live row now so subsequent tool events have a visible target.
-    const existing = [...migrated.messages].reverse().find(message => message.role === 'assistant' && message.isStreaming)
-    if (!transcriptSupported.value&&(migrated.isStreaming || inflightError || (existing && assistant))) {
-      migrated.messages = mergeChatMessages(migrated.messages, [{
-        ...existing,
-        id: existing?.id ?? `resume:${runtimeId}`,
-        sessionId: storedId,
-        profile: migrated.route.profile,
-        role: 'assistant',
-        content: assistant,
-        timestamp: number(result.turn_started_at, Date.now() / 1000),
-        stage: inflightError ? 'failed' : migrated.isStreaming ? 'streaming' : 'settled',
-        isStreaming: migrated.isStreaming,
-        error: inflightError || undefined,
-      }])
-    }
-    if (!migrated.isStreaming) {
-      migrated.liveStatus = undefined
-      if(!transcriptSupported.value)migrated.messages = settleChatMessages(migrated.messages)
-    }
-    migrated.pendingApproval = undefined
-    migrated.pendingClarification = undefined
-    values(transcriptSupported.value?[]:inflight.corrections).forEach((correction, index) => {
-      const content = string(correction)
-      if (!content) return
-      migrated.messages = mergeChatMessages(migrated.messages, [{
-        id: `resume-correction:${runtimeId}:${index}`,
-        sessionId: storedId,
-        profile: migrated.route.profile,
-        role: 'user',
-        content,
-        timestamp: number(result.turn_started_at, Date.now() / 1000) + (index + 1) / 1000,
-        stage: 'accepted',
-      }])
-    })
-    if (!transcriptSupported.value&&queuedUser) {
-      migrated.messages = mergeChatMessages(migrated.messages, [{
-        id: `resume-queued:${runtimeId}`,
-        sessionId: storedId,
-        profile: migrated.route.profile,
-        role: 'user',
-        content: queuedUser,
-        timestamp: Date.now() / 1000,
-        stage: 'accepted',
-      }])
-    }
-    const approval = record(result.pending_approval)
-    const approvalID = string(approval.request_id ?? approval.requestId ?? approval.id)
-    if (approvalID) migrated.pendingApproval = {
-      id: approvalID,
-      sessionId: storedId,
-      message: string(approval.message ?? approval.prompt) || undefined,
-      toolName: string(approval.tool_name ?? approval.tool) || undefined,
-      choices: Array.isArray(approval.choices) ? approval.choices.map(String) : undefined,
-      payload: approval as Record<string, JsonValue>,
-    }
-    const clarification = record(result.pending_clarify)
-    const clarificationID = string(clarification.request_id ?? clarification.requestId ?? clarification.id)
-    if (clarificationID) migrated.pendingClarification = {
-      id: clarificationID,
-      sessionId: storedId,
-      question: string(clarification.question ?? clarification.message ?? clarification.prompt, '需要补充信息'),
-      choices: Array.isArray(clarification.choices) ? clarification.choices.map(String) : undefined,
-      payload: clarification as Record<string, JsonValue>,
-    }
+    // session.resume restores the execution route only. The server ingests its
+    // snapshot into the canonical turn before clients receive transcript events.
     if (storedId !== initialState.route.sessionId) clearInflightMarker(initialState.route.profile, initialState.route.sessionId)
     updateInflightMarker(migrated)
     return migrated
@@ -881,6 +823,7 @@ export const useChatStore = defineStore('chat', () => {
       }
       updateDelivery(state, clientMessageId, { stage: files.length ? 'attached' : 'pending', sessionId: state.route.sessionId })
       updateDelivery(state, clientMessageId, { stage: 'pending' })
+      await outboxCache.set(cacheScope(state.route.profile),state.route.sessionId,state.messages.filter(m=>m.role==='user'&&m.stage!=='settled'),true)
       submitted = true
       const effectiveMode = mode === 'steer' && files.length ? 'queue' : mode
       const method = effectiveMode === 'steer' ? 'session.steer' : 'prompt.submit'
@@ -894,19 +837,8 @@ export const useChatStore = defineStore('chat', () => {
         throw new RpcError(string(result.error ?? result.message, 'Hermes 拒绝了 Steer 请求'), status)
       }
       updateDelivery(state, clientMessageId, { stage: 'accepted' })
-      const running = ['running', 'started', 'streaming'].includes(status)
-      if (effectiveMode === 'steer') {
-        // A steer receipt acknowledges injection into the current run. It is
-        // not evidence of a new run, including Hermes's `status: queued`.
-        state.isQueued = false
-        if (running) state.isStreaming = true
-      } else {
-        state.isQueued = status === 'queued'
-        if (running || status === 'accepted') {
-          state.isQueued = false
-          state.isStreaming = true
-        }
-      }
+      // A delayed HTTP receipt confirms the input, not a newer execution state.
+      // The transcript may already contain the completed reply at this point.
       updateInflightMarker(state)
       // The optimistic row remains local, but the sidebar is refreshed only
       // after a 9119 receipt and keeps the order returned by the server.

+ 14 - 4
src/client/utils/cache.ts

@@ -25,13 +25,23 @@ export class ScopedCache<T> {
     try { return await db.get('records', storageKey) as T | undefined } catch { return memory.get(storageKey) as T | undefined }
   }
 
-  async set(scope: string, key: string, value: T): Promise<void> {
+  async set(scope: string, key: string, value: T, durable = false): Promise<void> {
     const serialized = JSON.stringify(value)
-    if (new Blob([serialized]).size > this.maximumBytes) return
+    if (new Blob([serialized]).size > this.maximumBytes) {
+      if(durable)throw new Error('聊天缓存超出容量,未推进同步位置')
+      return
+    }
+    // Cache records are JSON snapshots. Detach reactive proxies before IndexedDB
+    // structured-clones them, and keep the memory fallback equally immutable.
+    const snapshot = JSON.parse(serialized) as T
     const storageKey = this.key(scope, key)
-    memory.set(storageKey, value)
     const db = await database()
-    if (db) await db.put('records', value, storageKey).catch(() => undefined)
+    if(durable&&typeof indexedDB!=='undefined'&&!db)throw new Error('聊天缓存不可写,未推进同步位置')
+    if (db) {
+      if(durable)await db.put('records',snapshot,storageKey)
+      else await db.put('records', snapshot, storageKey).catch(() => undefined)
+    }
+    memory.set(storageKey, snapshot)
   }
 
   async delete(scope: string, key: string): Promise<void> {

+ 8 - 3
src/runner/agent.ts

@@ -55,7 +55,7 @@ export class RunnerAgent {
     if(url.hostname==='localhost')url.hostname='127.0.0.1'
     const response=await (isLocalAuthorizationTarget(url)&&this.fetchImpl===fetch?this.controlTransport.fetch.bind(this.controlTransport):this.fetchImpl)(url,{
       method:body===undefined?'GET':'POST',redirect:'error',signal:AbortSignal.any([this.controlAbort.signal,AbortSignal.timeout(path==='desktop'?75000:25000)]),
-      headers:{Authorization:`Bearer ${this.config.token}`,'x-runner-instance':this.instance,'x-runner-protocol':'1','x-runner-features':this.computers?'host-computer-tools-v1,idle-stop-policy-v1,computer-worker-v1,artifact-chunks-v1,computer-control-v1,shared-computer-v1,local-vm-v1'+(this.computers.provider.fixedCapacity?',compose-desktops-v1':',helper-retirement-v1,image-options-v1')+(this.computers.config.imageId!==UNCONFIGURED_COMPUTER_IMAGE?',image-ready-v1':''):'',...(this.serverEpoch?{'x-runner-epoch':this.serverEpoch}:{}),'Content-Type':'application/json',...(path==='poll'&&!this.connected?{'x-runner-reset':'1'}:{})},
+      headers:{Authorization:`Bearer ${this.config.token}`,'x-runner-instance':this.instance,'x-runner-protocol':'1','x-runner-features':this.computers?'profile-computer-v1,host-computer-tools-v1,idle-stop-policy-v1,computer-worker-v1,artifact-chunks-v1,computer-control-v1,shared-computer-v1,local-vm-v1'+(this.computers.provider.fixedCapacity?',compose-desktops-v1':',helper-retirement-v1,image-options-v1')+(this.computers.config.imageId!==UNCONFIGURED_COMPUTER_IMAGE?',image-ready-v1':''):'',...(this.serverEpoch?{'x-runner-epoch':this.serverEpoch}:{}),'Content-Type':'application/json',...(path==='poll'&&!this.connected?{'x-runner-reset':'1'}:{})},
       ...(body===undefined?{}:{body:JSON.stringify(body)}),
     })
     if(!response.ok){
@@ -146,7 +146,7 @@ export class RunnerAgent {
     }
     if(command.kind==='http') {
       const path=String(p.path),search=new URLSearchParams(String(p.search??''))
-      if(path==='/api/computer/capabilities'||(p.computer&&path==='/api/plugins/yaoyao-bot-bridge/capabilities')){
+      if(path==='/api/computer/capabilities'||(p.computer&&!(p.computer as ComputerTarget).profileSession&&path==='/api/plugins/yaoyao-bot-bridge/capabilities')){
         this.requireProfile(search.get('profile')??'default')
         if(p.method!=='GET'||!this.computers)throw new HttpError(409,'执行节点未配置隔离电脑','computer_unavailable')
         await Promise.all([access(this.computers.config.python),access(this.computers.config.hermesSource),access(this.computers.script)])
@@ -156,6 +156,11 @@ export class RunnerAgent {
       if(p.computer&&/^\/api\/sessions\/[^/]+\/messages$/.test(path)){
         if(p.method!=='GET'||!this.computers)throw new HttpError(403,'电脑历史不可用','computer_unavailable')
         const profile=this.requireProfile(search.get('profile')??'default'),session=this.computers.session(decodeURIComponent(path.split('/')[3]!),p.computer as ComputerTarget,profile)
+        if(session.vmExecution==='profile'){
+          if(!session.profileSessionId)throw new HttpError(409,'本机 Profile 会话尚未建立','computer_profile_session_invalid')
+          const response=await this.target.session.request(`/api/sessions/${encodeURIComponent(session.profileSessionId)}/messages`,{search,maxResponseBytes:8*1024*1024})
+          return {status:response.status,headers:Object.fromEntries(response.headers.entries()),body:response.body.toString('base64')}
+        }
         const offset=Math.max(0,Number(search.get('offset')??0)),history=session.history
         return {status:200,headers:{},body:Buffer.from(JSON.stringify({messages:history.slice(Math.max(0,history.length-offset-500),history.length-offset)})).toString('base64')}
       }
@@ -176,7 +181,7 @@ export class RunnerAgent {
       if(p.computer){
         const meta=p.computer as ComputerTarget
         if(!this.computers||![meta.environmentId,meta.agentId,String(p.workId)].every(value=>/^[0-9a-f-]{36}$/.test(value))||!/^[a-f0-9]{64}$/.test(meta.ownerKey))throw new HttpError(409,'电脑任务配置或授权无效','computer_unavailable')
-        gateway=new ComputerGateway(this.computers,meta,String(p.workId),async()=>{if(!this.active||!this.connected||(await this.api('check',{connectionId})).allowed!==true)throw new HttpError(403,'电脑任务授权已失效','computer_authorization_revoked')},body=>this.api('artifact',{connectionId,...body}))
+        gateway=new ComputerGateway(this.computers,meta,String(p.workId),async()=>{if(!this.active||!this.connected||(await this.api('check',{connectionId})).allowed!==true)throw new HttpError(403,'电脑任务授权已失效','computer_authorization_revoked')},body=>this.api('artifact',{connectionId,...body}),meta.profileSession?this.target:undefined)
       }else gateway=new WorkspaceGateway(this.target)
       const connection:Connection={cleanupOnly:p.cleanupOnly===true,gateway,sessions:new Map(),running:new Set(),events:Promise.resolve()}
       this.connections.set(connectionId,connection)

+ 76 - 11
src/runner/worker/gateway.ts

@@ -6,7 +6,8 @@ import {existsSync} from 'node:fs'
 import type {DatabaseSync} from 'node:sqlite'
 import {z} from 'zod'
 import {HttpError} from '../../server/errors.js'
-import type {GatewayFrame} from '../../server/workspaceGateway.js'
+import type {GatewayFrame,GatewayTarget} from '../../server/workspaceGateway.js'
+import {ProfileComputerSession} from './profileSession.js'
 import {UNCONFIGURED_COMPUTER_IMAGE} from '../../shared/runner.js'
 import type {RunnerConfiguration} from '../../shared/runner.js'
 import {ContainerComputerProvider,COMPUTER_WORKSPACE,CUA_DRIVER,CUA_SOCKET,type ComputerSpecification} from '../computers/container.js'
@@ -19,8 +20,8 @@ import {HermesWorkerProcess,type WorkerModel,type WorkerProxyEnvironment,type Wo
 import {HOST_TOOLS,hostTool,hostPath,readHostFile,writeHostFile} from './hostTools.js'
 import {homedir,platform} from 'node:os'
 
-export interface ComputerTarget {environmentId:string;ownerKey:string;agentId:string;hostAccess?:boolean}
-export interface WorkerSession {agentId?:string;id:string;profile:string;ownerKey:string;environmentId:string;cwd:string;configuredCwd:string;history:any[];outcome?:'complete'|'failed'|'uncertain'}
+export interface ComputerTarget {environmentId:string;ownerKey:string;agentId:string;hostAccess?:boolean;profileSession?:boolean}
+export interface WorkerSession {agentId?:string;id:string;profile:string;ownerKey:string;environmentId:string;cwd:string;configuredCwd:string;history:any[];outcome?:'complete'|'failed'|'uncertain';vmExecution?:'profile';profileSessionId?:string}
 interface Live {workMarker?:string;paused?:boolean;pauseJob?:Promise<ComputerLease>;segment?:number;toolCalls:Set<Promise<unknown>>;journal:Map<string,{name:string;result:unknown}>;proxy?:ComputerPublicProxy;session:WorkerSession;model:WorkerModel;contextConfig?:WorkerContextConfiguration;proxyEnv?:WorkerProxyEnvironment;lease:ComputerLease;controller:AbortController;worker?:HermesWorkerProcess;finishing?:Promise<void>;stopping?:Promise<void>;releasing?:Promise<void>;images:any[];running:boolean;received:boolean}
 const object=(properties:Record<string,unknown>,required:string[])=>({type:'object',properties,required,additionalProperties:false})
 const text={type:'string'}
@@ -33,6 +34,7 @@ const TOOLS:WorkerTool[]=[
   {name:'computer_action',description:'在隔离电脑内调用 CUA 动作;先查看桌面并使用可用动作。',inputSchema:object({name:text,arguments:{type:'object'}},['name','arguments'])},
 ]
 const pathField=z.string().min(1).max(4096).refine(value=>!value.includes('\0'))
+const PROFILE_COMPUTER_RULES='当前使用本机协作模式:沿用基础 Profile 的本机工具、配置和上下文,本地虚拟机是独立的 Linux 电脑。computer_shell/read_file/write_file/desktop_state/action/export 只操作虚拟机;本机文件、终端和程序使用 Profile 已授权的原生工具。computer_copy_file 在两个环境间显式复制文件。调用前明确目标环境,文件路径和浏览器登录互不通用;需要回传虚拟机文件时使用 computer_export。人工接管期间停止操作,交还后先检查当前状态。'
 export class ComputerRuntime {
   retainDesktops=false
   readonly controls:ComputerControls
@@ -90,6 +92,7 @@ export class ComputerRuntime {
     const row=this.db.prepare('SELECT value FROM computer_sessions WHERE id=?').get(id) as {value:string}|undefined
     const session:WorkerSession|undefined=row?JSON.parse(row.value):undefined
     if(!session||(session.agentId??session.environmentId)!==meta.agentId||session.ownerKey!==meta.ownerKey||session.environmentId!==meta.environmentId||session.profile!==profile)throw new HttpError(404,'电脑会话不存在或不属于当前任务','computer_session_missing')
+    if((session.vmExecution==='profile')!==(meta.profileSession===true))throw new HttpError(409,'虚拟机执行方式已改变,请使用新会话','computer_session_mode_changed')
     return session
   }
   async resolve(profile:string,signal?:AbortSignal){
@@ -127,10 +130,11 @@ export class ComputerGateway {
   private timer?:ReturnType<typeof setInterval>
   private checking=false
   private hostCwd=homedir()
+  private profileSession?:ProfileComputerSession
   private team?:{id:string;catalog:WorkerTool[];call(name:string,args:Record<string,unknown>,callId:string):Promise<unknown>}
-  constructor(readonly runtime:ComputerRuntime,readonly meta:ComputerTarget,readonly workId:string,readonly check:()=>Promise<void>,readonly publish:(body:Record<string,unknown>)=>Promise<any>){ }
+  constructor(readonly runtime:ComputerRuntime,readonly meta:ComputerTarget,readonly workId:string,readonly check:()=>Promise<void>,readonly publish:(body:Record<string,unknown>)=>Promise<any>,readonly profileTarget?:GatewayTarget){ }
   async connect(){this.runtime.assertTarget(this.meta);await this.runtime.ready;await this.authorized()}
-  private async authorized(){try{await this.check();this.guard()}catch(error){await this.interrupt().catch(()=>{});if(!this.closed)this.onDisconnect();throw error}}
+  private async authorized(){try{await this.check();this.guard()}catch(error){const stopping=this.interrupt().catch(()=>{});if(!this.profileSession)await stopping;if(!this.closed)this.onDisconnect();throw error}}
   private guard(){if(this.closed||this.live?.controller.signal.aborted)throw new HttpError(410,'电脑任务授权已结束','computer_cancelled')}
   private event(type:string,payload:Record<string,unknown>){if(!this.closed&&this.live)this.onEvent({type,session_id:this.live.session.id,payload})}
   private spec(session:WorkerSession):ComputerSpecification{return {id:this.meta.environmentId,ownerKey:this.meta.ownerKey,imageId:this.runtime.imageFor(this.meta),cwd:session.cwd,network:this.runtime.config.network??'none'}}
@@ -141,12 +145,13 @@ export class ComputerGateway {
     if(method==='session.create'||method==='session.resume'){
       if(this.live)throw new HttpError(409,'电脑通道已有会话','computer_session_busy')
       await this.authorized()
-      if(method==='session.resume'&&params.recoverOnly===true){const session=this.runtime.session(String(params.session_id),this.meta,String(params.profile));this.recoverySession=session;const resource=this.runtime.pool.status(this.meta.ownerKey).find(item=>item.environmentId===this.meta.environmentId);if(resource?.holderId===this.workId)await this.runtime.pool.stopHolder(this.meta.ownerKey,this.meta.environmentId,this.workId);return {session_id:session.id,stored_session_id:session.id,running:false,info:{profile_name:session.profile}}}
+      if(method==='session.resume'&&params.recoverOnly===true){const session=this.runtime.session(String(params.session_id),this.meta,String(params.profile));this.recoverySession=session;if(this.meta.profileSession){await this.openProfile(session,params);await this.profileSession!.stop()}const resource=this.runtime.pool.status(this.meta.ownerKey).find(item=>item.environmentId===this.meta.environmentId);if(resource?.holderId===this.workId)await this.runtime.pool.stopHolder(this.meta.ownerKey,this.meta.environmentId,this.workId);return {session_id:session.id,stored_session_id:session.id,running:false,info:{profile_name:session.profile}}}
       if(this.runtime.imageFor(this.meta)===UNCONFIGURED_COMPUTER_IMAGE)throw new HttpError(409,'请先在应用设置的本地虚拟机页面完成准备','computer_image_required')
-      const profile=String(params.profile),resolved=await this.runtime.resolve(profile,this.controller.signal)
+      const profile=String(params.profile),resolved=await (this.meta.profileSession?this.runtime.resolveWorkspace(profile,this.controller.signal):this.runtime.resolve(profile,this.controller.signal))
       if(this.meta.hostAccess){const configured=String(resolved.configuredCwd??'.');this.hostCwd=['.','auto','cwd'].includes(configured)?homedir():hostPath(homedir(),configured)}
       await this.authorized();this.guard()
       const session:WorkerSession=method==='session.resume'?this.runtime.session(String(params.session_id),this.meta,profile):{id:randomUUID(),agentId:this.meta.agentId,ownerKey:this.meta.ownerKey,environmentId:this.meta.environmentId,profile,cwd:resolved.cwd,configuredCwd:resolved.configuredCwd,history:[]}
+      if(this.meta.profileSession)session.vmExecution='profile'
       session.cwd=this.meta.environmentId!==this.meta.agentId?(this.runtime.pool.definition(this.meta.ownerKey,this.meta.environmentId)?.cwd??COMPUTER_WORKSPACE):resolved.cwd;session.configuredCwd=resolved.configuredCwd
       await this.runtime.pool.configure(this.spec(session),()=>this.guard())
       await this.authorized()
@@ -160,11 +165,28 @@ export class ComputerGateway {
         catch(error){await this.interrupt();throw error}
       }
       this.timer=setInterval(()=>{if(this.checking)return;this.checking=true;void this.authorized().then(()=>this.runtime.pool.renew(this.live!.lease)).catch(async()=>{await this.interrupt().catch(()=>{});if(!this.closed)this.onDisconnect()}).finally(()=>{this.checking=false})},5000);this.timer.unref()
+      if(this.meta.profileSession){
+        try{const opened=await this.openProfile(session,params);return {...opened,session_id:session.id,stored_session_id:session.id}}
+        catch(error){await this.interrupt();throw error}
+      }
       return {session_id:session.id,stored_session_id:session.id,running:false,info:{profile_name:profile}}
     }
     const live=this.live
     if(!live||params.session_id!==live.session.id)throw new HttpError(403,'电脑会话不属于当前通道','computer_session_forbidden')
     if(method==='session.interrupt'||method==='session.close'){await this.interrupt();return {status:'interrupted'}}
+    if(this.profileSession){
+      if(method==='session.usage')return this.profileSession.rpc(method,params)
+      if(live.paused)throw new HttpError(409,'电脑正在等待人工操作','computer_paused')
+      await this.authorized()
+      if(method==='prompt.submit'){
+        if(live.running||live.received)throw new HttpError(409,'电脑会话已经提交过本轮','computer_session_busy')
+        if(typeof params.workMarker==='string'&&/^\[yaoyao-run:[0-9a-f-]{36}:[0-9a-f-]{36}\]$/.test(params.workMarker))live.workMarker=params.workMarker
+        await this.profileSession.bind();this.guard()
+        live.running=true;live.session.outcome='uncertain';this.runtime.save(live.session)
+        return this.profileSession.rpc(method,{...params,text:`${PROFILE_COMPUTER_RULES}\n${String(params.text??'')}`})
+      }
+      return this.profileSession.rpc(method,params)
+    }
     if(method==='session.usage')return {}
     if(method==='session.cwd.set'){
       if(params.cwd!==live.session.cwd&&params.cwd!==live.session.configuredCwd)throw new HttpError(403,'工作目录必须采用基础 Profile 的配置','computer_cwd_forbidden')
@@ -195,6 +217,40 @@ export class ComputerGateway {
     }
     throw new HttpError(409,'当前隔离 Worker 不支持此交互','computer_method_unavailable')
   }
+  private async openProfile(session:WorkerSession,params:Record<string,unknown>){
+    if(!this.profileTarget)throw new HttpError(409,'缺少本机 Profile 连接,请更新执行节点','computer_profile_unavailable')
+    if(params.session_id&&!session.profileSessionId)throw new HttpError(409,'本机 Profile 会话尚未建立,请新建会话','computer_profile_session_invalid')
+    const native=new ProfileComputerSession(this.profileTarget,session.profile,this.workId,()=>this.guard(),
+      ()=>[...TOOLS,...HOST_TOOLS.filter(tool=>tool.name==='computer_copy_file'),...(this.team?.catalog??[])],
+      async(name,args)=>{
+        const live=this.live
+        if(!live||!this.active||live.paused)throw new HttpError(410,'本轮电脑工具已结束或暂停','computer_cancelled')
+        const call=this.tool(live,name,args,randomUUID())
+        live.toolCalls.add(call);void call.finally(()=>live.toolCalls.delete(call)).catch(()=>{})
+        return call
+      })
+    this.profileSession=native
+    native.onStoredId=id=>{session.profileSessionId=id;this.runtime.save(session)}
+    native.onDisconnect=()=>{void this.interrupt().finally(()=>{if(!this.closed)this.onDisconnect()}).catch(()=>{})}
+    native.onEvent=frame=>{
+      const live=this.live
+      if(!live||this.closed||live.controller.signal.aborted||live.paused||live.received)return
+      if(['message.complete','run.completed','run.failed','message.error','error'].includes(frame.type)){
+        live.received=true
+        live.finishing=this.finishProfile(live,frame)
+        void live.finishing.catch(()=>this.lost(live))
+      }else this.event(frame.type,frame.type==='session.info'?{...frame.payload,stored_session_id:session.id,session_key:session.id}:frame.payload??{})
+    }
+    return native.open(session.profileSessionId,params)
+  }
+  private async finishProfile(live:Live,frame:GatewayFrame){
+    await Promise.allSettled([...live.toolCalls]);await this.authorized()
+    const payload=frame.payload??{},success=['message.complete','run.completed'].includes(frame.type)&&!payload.error&&!['interrupted','failed','error'].includes(String(payload.status))
+    live.session.outcome=success?'complete':'failed';this.runtime.save(live.session)
+    await this.release(live,this.runtime.retainDesktops&&success);live.running=false
+    if(this.closed||live.controller.signal.aborted)return
+    this.event(frame.type,{...payload,...(payload.status==='error'?{status:'failed'}:{})})
+  }
   private async startModel(live:Live,prompt:string,history:any[]){
       live.received=false;live.running=true;live.session.outcome='uncertain';live.session.history.push({role:'user',content:prompt});this.runtime.save(live.session)
       const directory=join(this.runtime.home,'workers',live.session.id,this.workId,String(live.segment=(live.segment??0)+1))
@@ -339,6 +395,7 @@ export class ComputerGateway {
     if(live.pauseJob)return live.pauseJob
     live.paused=true;this.event('computer.paused',{stage:'pausing'})
     live.pauseJob=(async()=>{
+      await this.profileSession?.stop()
       await live.worker?.close()
       await Promise.allSettled([...live.toolCalls])
       authorize();this.guard()
@@ -362,6 +419,11 @@ export class ComputerGateway {
     live.lease=await this.runtime.pool.transfer(live.lease,this.workId,()=>this.guard())
     live.paused=false;live.pauseJob=undefined;live.journal.clear()
     this.event('computer.resumed',{generation:live.lease.generation,notes})
+    if(this.profileSession){
+      await this.profileSession.bind();this.guard()
+      await this.profileSession.rpc('prompt.submit',{text:`${PROFILE_COMPUTER_RULES}\n用户已交还电脑控制权。请先检查当前状态,避免重复已完成的操作。交还说明:${notes||'无额外说明'}\n${live.workMarker??''}`})
+      return
+    }
     await this.startModel(live,`用户已完成电脑接管并明确交还控制。请先检查当前电脑状态,再继续原任务;不要重复已完成的副作用。用户说明:${notes||'无额外说明'}\n${live.workMarker??''}`,structuredClone(live.session.history))
   }
   async interrupt(){
@@ -369,12 +431,15 @@ export class ComputerGateway {
     if(live.stopping)return live.stopping
     live.stopping=(async()=>{
       live.controller.abort();clearInterval(this.timer)
-      await live.worker?.close()
-      try{await this.release(live)}catch(error){if((error as any).code!=='computer_lease_stale')throw error}
-      live.running=false
+      try{await this.profileSession?.stop()}
+      finally{
+        await this.profileSession?.close();await live.worker?.close()
+        try{await this.release(live)}catch(error){if((error as any).code!=='computer_lease_stale')throw error}
+        live.running=false
+      }
     })()
     return live.stopping
   }
   async stopControl(){await this.interrupt();this.event('message.complete',{text:'电脑控制已结束,本轮已停止',status:'interrupted'})}
-  close(){if(this.runtime.gateways.get(this.meta.environmentId)===this)this.runtime.gateways.delete(this.meta.environmentId);this.closed=true;this.controller.abort();this.team=undefined;clearInterval(this.timer);return this.interrupt()}
+  async close(){if(this.runtime.gateways.get(this.meta.environmentId)===this)this.runtime.gateways.delete(this.meta.environmentId);this.closed=true;this.controller.abort();this.team=undefined;clearInterval(this.timer);try{if(this.live?.running||this.live&&!this.live.releasing)await this.interrupt()}finally{await this.profileSession?.close()}}
 }

+ 92 - 0
src/runner/worker/profileSession.ts

@@ -0,0 +1,92 @@
+import {setTimeout as delay} from 'node:timers/promises'
+import {HttpError} from '../../server/errors.js'
+import {WorkspaceGateway,type GatewayFrame,type GatewayTarget} from '../../server/workspaceGateway.js'
+import {createWorkspaceToolLease,requireTeamToolBridge,type WorkspaceToolLease} from '../../server/workspaceToolLease.js'
+import type {WorkerTool} from './process.js'
+
+/** A normal Hermes Profile session, with the same native tool bridge as cloud computers. */
+export class ProfileComputerSession {
+  private readonly gateway:WorkspaceGateway
+  private toolLease?:WorkspaceToolLease
+  private runtimeId=''
+  storedId=''
+  private closed=false
+  private readonly controller=new AbortController()
+  onEvent:(frame:GatewayFrame)=>void=()=>{}
+  onDisconnect:()=>void=()=>{}
+  onStoredId:(id:string)=>void=()=>{}
+  constructor(readonly target:GatewayTarget,readonly profile:string,readonly workId:string,
+    readonly authorize:()=>void,readonly catalog:()=>WorkerTool[],
+    readonly call:(name:string,args:unknown,id:string)=>Promise<unknown>){
+    this.gateway=new WorkspaceGateway(target)
+    this.gateway.onDisconnect=()=>{if(!this.closed)this.onDisconnect()}
+    this.gateway.onEvent=frame=>{
+      if(this.closed||!this.runtimeId||frame.session_id!==this.runtimeId)return
+      if(frame.type==='session.info'){
+        const id=frame.payload?.stored_session_id??frame.payload?.session_key
+        if(typeof id==='string'&&id){this.storedId=id;this.onStoredId(id)}
+      }
+      this.onEvent(frame)
+    }
+  }
+  async open(storedId:string|undefined,params:Record<string,unknown>){
+    await this.gateway.connect()
+    const {session_id:_virtual,recoverOnly:_recover,...options}=params
+    const opened=await this.gateway.rpc(storedId?'session.resume':'session.create',{
+      ...options,profile:this.profile,close_on_disconnect:false,...(storedId?{session_id:storedId}:{}),
+    })
+    this.runtimeId=String(opened.session_id??'')
+    this.storedId=String(opened.stored_session_id??opened.session_key??storedId??'')
+    if(!this.runtimeId||!this.storedId)throw new HttpError(502,'本机 Profile 会话身份不完整','computer_profile_session_invalid')
+    this.onStoredId(this.storedId)
+    return opened
+  }
+  async bind(){
+    this.authorize()
+    if(!this.toolLease){
+      await requireTeamToolBridge(this.target,this.profile)
+      this.toolLease=await createWorkspaceToolLease({target:this.target,profile:this.profile,workId:this.workId,
+        session:()=>({runtimeId:this.runtimeId,storedId:this.storedId}),signal:this.controller.signal,
+        assertActive:()=>{this.controller.signal.throwIfAborted();this.authorize()},
+        catalog:()=>this.catalog().map(tool=>({...tool,id:tool.id??tool.name})),
+        call:async(name,args,id)=>{
+          const value=await this.call(name,args,id!)
+          // Hermes Worker uses OpenAI image blocks; the Profile bridge speaks MCP.
+          if(value&&typeof value==='object'&&(value as any)._multimodal){
+            const result=value as any
+            return {content:[{type:'text',text:result.text_summary??''},...result.content.map((item:any)=>{
+              const match=/^data:(image\/[a-z]+);base64,(.+)$/.exec(item.image_url?.url??'')
+              if(!match)throw new Error('虚拟机截图格式无效')
+              return {type:'image',mimeType:match[1],data:match[2]}
+            })]}
+          }
+          return value
+        },onFailure:()=>{void this.stop().finally(()=>this.onDisconnect()).catch(()=>{})},
+      })
+    }
+    await this.toolLease.bind()
+  }
+  rpc(method:string,params:Record<string,unknown>={}){
+    const {session_id:_virtual,workMarker:_marker,...options}=params
+    return this.gateway.rpc(method,{...options,session_id:this.runtimeId})
+  }
+  async stop(){
+    if(!this.runtimeId||this.closed)return
+    await this.rpc('session.interrupt')
+    // An interrupt acknowledgement precedes actual termination of native tools.
+    const deadline=Date.now()+20000
+    for(;;){
+      const state=await this.rpc('session.active_list')
+      const session=state.sessions?.find((item:{id:string})=>item.id===this.runtimeId)
+      if(session?.status==='idle')return
+      if(Date.now()>=deadline)throw new HttpError(409,'本机任务尚未停止,暂不能交出电脑控制权','computer_profile_stopping')
+      await delay(100,undefined,{signal:this.controller.signal})
+    }
+  }
+  async close(){
+    if(this.closed)return
+    this.closed=true;this.controller.abort()
+    await this.toolLease?.dispose()
+    this.gateway.close()
+  }
+}

+ 5 - 7
src/server/app.ts

@@ -265,14 +265,10 @@ export function createApplication(options: ApplicationOptions = {}): Application
   realtime.transcriptsAvailable = chatCache.store.transcripts.enabled
   realtime.broker.onNativeEvent = (owner, profile, storedId, frame) => {
     chatCache?.observe(owner, profile, storedId, frame)
-    if(/^(message\.(start|delta|interim|complete)|reasoning\.|tool\.|run\.(completed|failed))/.test(frame.type)){
-      const id=chatCache?.store.projectedMessageID(owner,profile,storedId)
-      if(id)frame.payload={...frame.payload,message_id:id}
-    }
     if (owner.startsWith('device:')) return
     if (!['message.complete', 'attachment.staged'].includes(frame.type)) return
     const data = frame.payload ?? {}, text = frame.type === 'attachment.staged' ? JSON.stringify(data) : nativeMessageFileText(data)
-    const messageId = String(data.row_id ?? data.message_id ?? data.id ?? createHash('sha256').update(text).digest('hex'))
+    const messageId = String(chatCache.store.projectedMessageID(owner,profile,storedId) ?? data.row_id ?? data.message_id ?? data.id ?? createHash('sha256').update(text).digest('hex'))
     void workspaceAssets.archiveText(owner, text, 'local', profile, storedId, messageId, frame.type === 'attachment.staged' ? 'user' : 'agent').catch(() => {})
   }
   workspace.nativeMessageForFile = (owner, file) => {
@@ -292,8 +288,10 @@ export function createApplication(options: ApplicationOptions = {}): Application
   realtime.broker.onNativeCommand = (owner, profile, storedId, method, params) => {
     chatCache?.command(owner, profile, storedId, method, params)
   }
-  realtime.broker.onNativeRoute = (owner, profile, storedId, runtimeId, running) => {
-    chatCache?.route(owner, profile, storedId, runtimeId, running)
+  realtime.broker.nativeSourceCursor = (owner,profile,id,runtime,epoch)=>chatCache.store.transcripts.sourceCursor(owner,profile,id,runtime,epoch)
+  realtime.broker.onNativeRoute = (owner, profile, storedId, runtimeId, running, snapshot) => {
+    chatCache?.route(owner, profile, storedId, runtimeId, snapshot?undefined:running)
+    if(snapshot)chatCache.store.recordEvent(owner,profile,storedId,{type:'route.resumed',payload:snapshot})
   }
   chatPushJobs.setTransportFactory(realtime.recoveryTransport, job => realtime.ownsPushJob(job.id))
   try {

+ 66 - 75
src/server/chatCache.ts

@@ -1,4 +1,3 @@
-import { projectChatEvent } from './chatEventProjection.js'
 import { ChatTranscriptStore } from './chatTranscriptStore.js'
 import { isFinalChatResult } from './chatUnread.js'
 import { HttpError } from './errors.js'
@@ -138,6 +137,7 @@ function referencedPaths(value: unknown, output = new Set<string>()): Set<string
 }
 
 export class ChatCacheStore {
+  private synchronizingHistory = false
   readonly db: DatabaseSync
   readonly assetsRoot: string
   readonly transcripts: ChatTranscriptStore
@@ -382,12 +382,10 @@ export class ChatCacheStore {
       CASE WHEN COALESCE(l.read_initialized,0)=1 THEN l.read_count ELSE COALESCE(s.message_total,0) END read_message_count FROM chat_sessions s LEFT JOIN chat_local_state l USING(owner,profile,session_id)
       WHERE s.owner=? AND s.owned_at IS NOT NULL AND (?='' OR s.profile=?)`).all(owner,profile,profile) as any[])
       .map(({final_read_count,...r})=>{
-        const messages = this.db.prepare(`SELECT data FROM chat_messages
-          WHERE owner=? AND profile=? AND session_id=? AND position>=?
-          AND json_extract(data,'$.role')='assistant'`)
-          .all(owner,r.profile,r.session_id,final_read_count) as {data:string}[]
+        this.transcripts.seed(owner,r.profile,r.session_id)
+        r.message_count=this.transcripts.total(owner,r.profile,r.session_id)
         return {...r,updated_at:Date.now(),unread_count:Math.max(0,r.message_count-r.read_message_count),
-          final_unread_count:messages.filter(row=>isFinalChatResult(JSON.parse(row.data))).length}
+          final_unread_count:this.transcripts.unread(owner,r.profile,r.session_id)}
       })
     return {profile,supported:true,total_unread:sessions.reduce((n,r)=>n+r.unread_count,0),sessions}
   }
@@ -395,8 +393,8 @@ export class ChatCacheStore {
   markRead(owner: string, profile: string, id: string, count?: number) {
     id=this.canonicalSessionID(owner,profile,id)
     this.requireOwned(owner,profile,id)
-    const total = Number((this.db.prepare('SELECT message_total FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?')
-      .get(owner,profile,id) as any).message_total ?? 0)
+    this.transcripts.seed(owner,profile,id)
+    const total = this.transcripts.total(owner,profile,id)
     const read = Math.max(0,Math.min(total, count ?? total))
     // Reading a streaming placeholder must not consume its future final answer.
     // Keep the original cursor untouched for existing consumers.
@@ -409,6 +407,8 @@ export class ChatCacheStore {
     this.db.prepare(`INSERT INTO chat_local_state(owner,profile,session_id,read_count,final_read_count,read_initialized) VALUES(?,?,?,?,?,1)
       ON CONFLICT(owner,profile,session_id) DO UPDATE SET read_count=MAX(read_count,excluded.read_count),
       final_read_count=MAX(COALESCE(final_read_count,read_count),excluded.final_read_count),read_initialized=1`).run(owner,profile,id,read,finalRead)
+    this.transcripts.seed(owner,profile,id)
+    this.transcripts.markRead(owner,profile,id,count??Infinity)
     return this.unread(owner,profile).sessions.find(r=>r.session_id===id)!
   }
 
@@ -425,7 +425,7 @@ export class ChatCacheStore {
         ON CONFLICT(owner,profile,session_id) DO UPDATE SET pinned=excluded.pinned`).run(owner,profile,id,patch.pinned?1:0)
       const row = this.localDetail(owner,profile,id)!
       const data = {...JSON.parse(row.response.body.toString()),...patch}
-      this.db.prepare('UPDATE chat_sessions SET data=? WHERE owner=? AND profile=? AND session_id=?').run(JSON.stringify(data),owner,profile,id)
+      this.db.prepare("UPDATE chat_sessions SET data=?,sync_state=CASE WHEN sync_state='gap' THEN sync_state WHEN complete=1 THEN 'current' ELSE sync_state END WHERE owner=? AND profile=? AND session_id=?").run(JSON.stringify(data),owner,profile,id)
       for(const key of ['title','archived'] as const)if(patch[key]!==undefined){
         const value=key==='archived'?(patch[key]?1:0):String(patch[key])
         this.db.prepare(`INSERT INTO chat_local_state(owner,profile,session_id,${key}) VALUES(?,?,?,?) ON CONFLICT(owner,profile,session_id) DO UPDATE SET ${key}=excluded.${key}`).run(owner,profile,id,value)
@@ -437,61 +437,23 @@ export class ChatCacheStore {
     } catch(e) {this.db.exec('ROLLBACK TO local_chat_patch; RELEASE local_chat_patch');throw e}
   }
 
-  private writeLiveMessage(owner:string,profile:string,id:string,message:Record<string,any>): void {
-    const prior = this.db.prepare('SELECT position FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND message_id=?').get(owner,profile,id,message.id) as {position:number}|undefined
-    const row = this.db.prepare('SELECT message_total,complete,data FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,id) as any
-    const extent = Number((this.db.prepare('SELECT COALESCE(MAX(position)+1,0) n FROM chat_messages WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,id) as any).n)
-    const position = prior?.position ?? Math.max(extent,Number(row.message_total??0))
-    const data=JSON.stringify(message)
-    this.db.prepare(`INSERT INTO chat_messages(owner,profile,session_id,message_id,position,data,content_hash) VALUES(?,?,?,?,?,?,?)
-      ON CONFLICT(owner,profile,session_id,message_id) DO UPDATE SET data=excluded.data,content_hash=excluded.content_hash`).run(owner,profile,id,message.id,position,data,createHash('sha256').update(data).digest('hex'))
-    const total=Math.max(Number(row.message_total??0),position+1), summary=JSON.parse(row.data)
-    const now=Date.now()
-    summary.message_count=total; summary.last_active=now/1000
-    if (typeof message.content==='string' && message.content.trim()) summary.preview=message.content.slice(0,160)
-    this.db.prepare('UPDATE chat_sessions SET data=?,message_total=?,last_synced_at=? WHERE owner=? AND profile=? AND session_id=?').run(JSON.stringify(summary),total,now,owner,profile,id)
-    for(const path of referencedPaths(message)) this.db.prepare(`INSERT OR IGNORE INTO chat_attachments(owner,profile,session_id,source_path,state,updated_at) VALUES(?,?,?,?,'pending',?)`).run(owner,profile,id,path,now)
-    this.transcripts.upsert(owner,profile,id,message,position)
-  }
-
   projectedMessageID(owner:string,profile:string,id:string):string|undefined {
-    return (this.db.prepare(`SELECT message_id FROM chat_messages WHERE owner=? AND profile=? AND session_id=?
-      AND json_extract(data,'$.role')='assistant' ORDER BY position DESC LIMIT 1`).get(owner,profile,id) as {message_id:string}|undefined)?.message_id
+    return this.transcripts.head(owner,profile,id).current
   }
 
-  private projectEvent(owner:string,profile:string,id:string,type:string,p:Record<string,any>,eventID:string): void {
-    if(!this.ownsSession(owner,profile,id))return
-    if(type==='command.confirmed'||type==='command.rejected'){
-      const userID=`user:${p.delivery_id}`
-      const row=this.db.prepare('SELECT data FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND message_id=?').get(owner,profile,id,userID) as any
-      if(row)this.writeLiveMessage(owner,profile,id,{...JSON.parse(row.data),status:type==='command.confirmed'?'complete':'failed',...(p.error?{error:p.error}:{})})
-      this.db.prepare("UPDATE chat_sessions SET sync_state=CASE WHEN sync_state='gap' THEN 'gap' WHEN complete=1 THEN 'current' ELSE 'stale' END WHERE owner=? AND profile=? AND session_id=?").run(owner,profile,id)
-      return
-    }
-    if (type==='message.user' || type==='peer_user_message') {
-      this.writeLiveMessage(owner,profile,id,{...p,id:String(p.message_id??p.id??eventID),role:'user',content:p.text??p.content??'',timestamp:Date.now()/1000});return
-    }
-    const state=this.db.prepare('SELECT assistant_id FROM chat_local_state WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,id) as any
-    const last=state?.assistant_id?this.db.prepare('SELECT data FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND message_id=?').get(owner,profile,id,state.assistant_id) as any:undefined
-    const previous=last?JSON.parse(last.data):undefined
-    // A new run must never append to the assistant row from the preceding turn.
-    if(['message.complete','run.completed'].includes(type) && !previous && !p.text && !p.content && !p.message){
-      this.db.prepare("UPDATE chat_sessions SET sync_state='gap' WHERE owner=? AND profile=? AND session_id=?").run(owner,profile,id);return
-    }
-    const startsNew=type==='message.start' && previous?.status!=='streaming'
-    const message=projectChatEvent(type,p,startsNew?undefined:previous,`event:${eventID}`,Date.now())
-    if(message){
-      if(previous && previous.id !== message.id && !startsNew){
-        const exists=this.db.prepare('SELECT 1 FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND message_id=?').get(owner,profile,id,message.id)
-        if(!exists){this.transcripts.promote(owner,profile,id,String(previous.id),String(message.id));this.db.prepare('UPDATE chat_messages SET message_id=? WHERE owner=? AND profile=? AND session_id=? AND message_id=?').run(message.id,owner,profile,id,previous.id)}
-        else {this.db.prepare("UPDATE chat_sessions SET sync_state='gap' WHERE owner=? AND profile=? AND session_id=?").run(owner,profile,id);return}
-      }
-      this.writeLiveMessage(owner,profile,id,message)
-      this.db.prepare(`INSERT INTO chat_local_state(owner,profile,session_id,assistant_id) VALUES(?,?,?,?)
-        ON CONFLICT(owner,profile,session_id) DO UPDATE SET assistant_id=excluded.assistant_id`).run(owner,profile,id,type==='message.interim'?null:message.id)
-      this.db.prepare(`UPDATE chat_sessions SET sync_state=CASE WHEN sync_state='gap' THEN 'gap' WHEN complete=1 THEN 'current' ELSE 'stale' END
-        WHERE owner=? AND profile=? AND session_id=?`).run(owner,profile,id)
-    }
+  private updateTranscriptSummary(owner:string,profile:string,id:string):void {
+    const total=this.transcripts.total(owner,profile,id)
+    const lastRow=this.db.prepare('SELECT data FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0 ORDER BY seq DESC LIMIT 1').get(owner,profile,id)
+    const last=lastRow?JSON.parse(String(lastRow.data)):undefined
+    const row=this.db.prepare('SELECT data FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,id)
+    if(!row)return
+    const data=JSON.parse(String(row.data))
+    data.message_count=total
+    if(last){data.last_active=last.timestamp;if(typeof last.content==='string'&&last.content.trim())data.preview=last.content.slice(0,160)}
+    this.db.prepare("UPDATE chat_sessions SET data=?,sync_state=CASE WHEN sync_state='gap' THEN sync_state WHEN complete=1 THEN 'current' ELSE sync_state END WHERE owner=? AND profile=? AND session_id=?").run(JSON.stringify(data),owner,profile,id)
+    const currentID=this.transcripts.head(owner,profile,id).current
+    const current=currentID?this.transcripts.message(owner,profile,id,currentID):undefined
+    for(const message of [last,current].filter(Boolean))for(const path of referencedPaths(message!))this.db.prepare(`INSERT OR IGNORE INTO chat_attachments(owner,profile,session_id,source_path,state,updated_at) VALUES(?,?,?,?,'pending',?)`).run(owner,profile,id,path,Date.now())
   }
 
   needsListMetadata(owner: string, profile: string): boolean {
@@ -536,6 +498,7 @@ export class ChatCacheStore {
       // Hydrate all registered sessions from the unsliced upstream list, while
       // persisting only the owner-filtered page as the public response snapshot.
       this.ingestPayload(owner, profile, sessionID, parseResponse(metadataResponse) ?? payload, now, kind, requestStartedAt)
+      if(kind==='messages'&&sessionID&&!this.synchronizingHistory&&!this.transcripts.head(owner,profile,sessionID).running){this.transcripts.reconcile(owner,profile,sessionID);this.updateTranscriptSummary(owner,profile,sessionID)}
       this.db.prepare(`INSERT INTO chat_snapshots(owner,cache_key,kind,profile,session_id,status,headers,body,sync_state,saved_at)
         VALUES(?,?,?,?,?,?,?,?,?,?) ON CONFLICT(owner,cache_key) DO UPDATE SET status=excluded.status,headers=excluded.headers,
         body=excluded.body,sync_state='current',saved_at=excluded.saved_at`)
@@ -551,9 +514,11 @@ export class ChatCacheStore {
 
   applySync(owner: string, profile: string, sessionID: string, revision: number,
     pages: Array<{ key: string; kind: string; response: UpstreamResponse; startedAt: number }>, force: boolean): boolean {
-    if (this.revision(owner, profile, sessionID) !== revision) return false
+    if (this.revision(owner, profile, sessionID) !== revision || this.transcripts.head(owner,profile,sessionID).running) return false
     this.db.exec('SAVEPOINT history_sync')
+    this.synchronizingHistory=true
     try {
+      this.transcripts.archive([owner,profile,sessionID])
       if (force) this.db.prepare('DELETE FROM chat_messages WHERE owner=? AND profile=? AND session_id=?').run(owner, profile, sessionID)
       // Recovery promotes locally generated stream identities to upstream row IDs.
       // Remove only replaced rows inside the verified window; keep older coverage.
@@ -584,7 +549,7 @@ export class ChatCacheStore {
       for (const page of pages) this.putSnapshot(owner, page.key, page.kind, profile, sessionID, page.response, false, page.startedAt)
       // Resolve legacy identities only after all pages are stored. Resolving
       // pages individually could consume a send before seeing an ambiguous row.
-      const coverage = this.db.prepare('SELECT complete FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?')
+      const coverage = this.db.prepare('SELECT complete,message_total FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?')
         .get(owner, profile, sessionID) as {complete: number} | undefined
       if (coverage?.complete) this.userMessageIdentities(owner, profile, sessionID, pages.flatMap(page => {
         const messages = page.kind === 'messages' ? parseResponse(page.response)?.messages : undefined
@@ -593,10 +558,13 @@ export class ChatCacheStore {
       const latest=this.db.prepare("SELECT message_id FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND json_extract(data,'$.role')='assistant' ORDER BY position DESC LIMIT 1").get(owner,profile,sessionID) as {message_id:string}|undefined
       if(latest)this.db.prepare('UPDATE chat_local_state SET assistant_id=? WHERE owner=? AND profile=? AND session_id=?').run(latest.message_id,owner,profile,sessionID)
       this.transcripts.reconcile(owner,profile,sessionID)
+      this.updateTranscriptSummary(owner,profile,sessionID)
       this.transcripts.sessionChanged(owner,profile,sessionID,{eventType:'history.synced'})
+      this.synchronizingHistory=false
       this.db.exec('RELEASE history_sync')
       return true
     } catch (error) {
+      this.synchronizingHistory=false
       this.db.exec('ROLLBACK TO history_sync; RELEASE history_sync')
       throw error
     }
@@ -679,6 +647,21 @@ export class ChatCacheStore {
   }
 
   messagePage(owner: string, profile: string, sessionID: string, offset: number, limit: number): MessagePage | undefined {
+    if(!this.ownsSession(owner,profile,sessionID))return this.sourceMessagePage(owner,profile,sessionID,offset,limit)
+    this.transcripts.seed(owner,profile,sessionID)
+    const known=this.db.prepare('SELECT complete,message_total FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,sessionID)
+    if(!known?.complete&&!this.transcripts.total(owner,profile,sessionID))return undefined
+    const all=this.transcripts.all(owner,profile,sessionID),end=Math.max(0,all.length-offset),start=Math.max(0,end-limit)
+    const total=known?.complete?all.length:Math.max(all.length,Number(known?.message_total??0))
+    if(!known?.complete&&offset>=all.length&&offset<total)return undefined
+    const detail=this.localDetail(owner,profile,sessionID)!
+    return {state:detail.state,response:{status:200,headers:new Headers({'content-type':'application/json'}),body:Buffer.from(JSON.stringify({
+      session_id:sessionID,session:JSON.parse(detail.response.body.toString()),messages:all.slice(start,end),
+      pagination:{total,returned:end-start,offset,limit,has_more:start>0||total>all.length}
+    }))}}
+  }
+
+  sourceMessagePage(owner: string, profile: string, sessionID: string, offset: number, limit: number): MessagePage | undefined {
     const session = this.db.prepare(`SELECT data,sync_state,complete,message_total FROM chat_sessions
       WHERE owner=? AND profile=? AND session_id=?`).get(owner, profile, sessionID) as Record<string, unknown> | undefined
     if (!session) return undefined
@@ -755,8 +738,11 @@ export class ChatCacheStore {
       VALUES(?,?,?,?,?) ON CONFLICT(owner,profile) DO UPDATE SET event_cursor=MAX(event_cursor,excluded.event_cursor),
       sync_state=excluded.sync_state,last_synced_at=excluded.last_synced_at`)
       .run(owner, profile, rawSeq > 0 ? rawSeq : lastSeen, state, now)
-    this.projectEvent(owner,profile,sessionID,type,object(frame.payload)??{},eventID)
-    if (!['message.delta','reasoning.delta','thinking.delta'].includes(type)&&!type.startsWith('tool.')) this.transcripts.sessionChanged(owner,profile,sessionID,{eventType:type,payload:object(frame.payload)??{}})
+    if(this.ownsSession(owner,profile,sessionID)){
+      this.transcripts.recordSource([owner,profile,sessionID],frame)
+      this.transcripts.reduce(owner,profile,sessionID,type,object(frame.payload)??{})
+      this.updateTranscriptSummary(owner,profile,sessionID)
+    }
     this.db.exec('RELEASE live_event')
     return true
     }catch(e){this.db.exec('ROLLBACK TO live_event; RELEASE live_event');throw e}
@@ -823,13 +809,10 @@ export class ChatCacheStore {
         establishesOwnership ? now : null, establishesOwnership ? `command:${method}` : null)
     if(method==='session.create') this.db.prepare(`INSERT INTO chat_local_state(owner,profile,session_id,read_initialized) VALUES(?,?,?,1) ON CONFLICT(owner,profile,session_id) DO UPDATE SET read_initialized=1`).run(owner,profile,sessionID)
     if(method==='session.create') this.db.prepare(`UPDATE chat_sessions SET complete=1,metadata_complete=1,message_total=0,sync_state='current' WHERE owner=? AND profile=? AND session_id=? AND message_total IS NULL`).run(owner,profile,sessionID)
+    this.transcripts.seed(owner,profile,sessionID)
     if((method==='prompt.submit'||method==='session.steer') && params._delivery_id){
-      const userID=`user:${params._delivery_id}`
-      this.writeLiveMessage(owner,profile,sessionID,{id:userID,role:'user',content:params.text??params.input??'',timestamp:now/1000,status:'pending',client_message_id:String(params._delivery_id).replace(/^(web|ios):prompt:/,'')})
-      const streaming=this.db.prepare(`SELECT 1 FROM chat_local_state l JOIN chat_messages m ON m.owner=l.owner AND m.profile=l.profile AND m.session_id=l.session_id AND m.message_id=l.assistant_id
-        WHERE l.owner=? AND l.profile=? AND l.session_id=? AND json_extract(m.data,'$.status')='streaming'`).get(owner,profile,sessionID)
-      if(!streaming)this.db.prepare(`INSERT INTO chat_local_state(owner,profile,session_id,assistant_id) VALUES(?,?,?,NULL) ON CONFLICT(owner,profile,session_id) DO UPDATE SET assistant_id=NULL`).run(owner,profile,sessionID)
-      this.transcripts.sessionChanged(owner,profile,sessionID,{eventType:'command.submitted',payload:{delivery_id:params._delivery_id}})
+      this.transcripts.reduce(owner,profile,sessionID,'command.submitted',{...params,method,delivery_id:params._delivery_id})
+      this.updateTranscriptSummary(owner,profile,sessionID)
     }
     const payload = JSON.stringify(params)
     const seq = Number.parseInt(createHash('sha256').update(`${method}:${payload}`).digest('hex').slice(0, 12), 16)
@@ -842,6 +825,8 @@ export class ChatCacheStore {
   }
 
   fileSourceMessage(owner: string, profile: string, sessionID: string, messageID: string): Record<string, unknown> | undefined {
+    const canonical=this.transcripts.resolveMessage(owner,profile,sessionID,messageID)
+    if(canonical)return canonical
     const row = this.db.prepare('SELECT data FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND message_id=?')
       .get(owner, profile, sessionID, messageID)
     return row ? JSON.parse(String(row.data)) : undefined
@@ -1246,7 +1231,6 @@ export class ChatCacheStore {
         WHERE chat_messages.content_hash<>excluded.content_hash OR chat_messages.position<>excluded.position`)
         .run(owner, profile, sessionID, messageID(message, String(start + index)), start + index, data,
           createHash('sha256').update(data).digest('hex'))
-      this.transcripts.upsert(owner,profile,sessionID,{...message,id:messageID(message,String(start+index))},start+index)
       for (const sourcePath of referencedPaths(message)) {
         this.db.prepare(`INSERT INTO chat_attachments(owner,profile,session_id,source_path,state,updated_at)
           VALUES(?,?,?,?,?,?) ON CONFLICT(owner,profile,session_id,source_path) DO UPDATE SET updated_at=excluded.updated_at`)
@@ -1302,6 +1286,8 @@ export class ChatCacheCoordinator {
         this.retryTimers.delete(timer)
         if(this.store.isClosed||this.stopped)return
         void this.restoreReadPositions()
+        for(const row of this.store.db.prepare("SELECT owner,profile,session_id FROM chat_sessions WHERE owned_at IS NOT NULL").all() as any[]){this.store.transcripts.seed(row.owner,row.profile,row.session_id)}
+        for(const row of this.store.db.prepare("SELECT * FROM chat_transcript_repairs WHERE status='pending'").all() as any[])this.schedule(row.owner,row.profile,row.session_id,true)
         for(const row of this.store.db.prepare('SELECT * FROM chat_recovery_jobs').all() as any[])this.schedule(row.owner,row.profile,row.session_id,!!row.force)
       },0);timer.unref();this.retryTimers.add(timer)
     }
@@ -1476,15 +1462,18 @@ export class ChatCacheCoordinator {
     const key = JSON.stringify([owner, profile, sessionID])
     const pending = this.reconciling.get(key)
     if (pending) {
-      await pending.catch(() => {})
-      if (force || this.store.localDetail(owner, profile, sessionID)?.state !== 'current') {
+      const failed=await pending.then(()=>false,()=>true)
+      if (failed || force || this.store.localDetail(owner, profile, sessionID)?.state !== 'current') {
         return this.reconcile(owner, profile, sessionID, force)
       }
       return
     }
     const task = (async () => {
+      if(this.store.transcripts.head(owner,profile,sessionID).running)throw new Error('Conversation is running; defer history repair')
+      const repair=this.store.db.prepare("SELECT 1 FROM chat_transcript_repairs WHERE owner=? AND profile=? AND session_id=? AND status='pending'").get(owner,profile,sessionID)
+      force ||= !!repair
       const revision = this.store.revision(owner, profile, sessionID)
-      const previous = this.store.messagePage(owner, profile, sessionID, 0, 1)
+      const previous = this.store.sourceMessagePage(owner, profile, sessionID, 0, 1)
       const previousTotal = previous ? Number(object(parseResponse(previous.response)?.pagination)?.total ?? 0) : 0
       const detailPath = `/api/sessions/${encodeURIComponent(sessionID)}`
       const detailStartedAt = Date.now()
@@ -1560,6 +1549,8 @@ export class ChatCacheCoordinator {
         // Its completion joins this flight and schedules the next tail read.
         throw new Error('Conversation changed during refresh; retry after the reply completes')
       } else {
+        if(this.store.db.prepare("SELECT 1 FROM chat_transcript_repairs WHERE owner=? AND profile=? AND session_id=? AND status='pending'").get(owner,profile,sessionID))
+          throw new Error('History identity is not yet confirmed; preserve the existing conversation')
         this.onSynchronized(owner, profile, sessionID)
       }
     })().finally(() => { if (this.reconciling.get(key) === task) this.reconciling.delete(key) })

+ 0 - 55
src/server/chatEventProjection.ts

@@ -1,55 +0,0 @@
-import { toolStatus } from '../shared/chatTools.js'
-/** Shared durable representation of an ordinary Hermes turn. No client timers or UI state. */
-export type ChatRecord = Record<string, any>
-const text = (p: ChatRecord) => String(p.delta ?? p.text_delta ?? p.content_delta ?? p.text ?? '')
-export function projectChatEvent(type: string, payload: ChatRecord, previous: ChatRecord | undefined,
-  fallbackID: string, now: number): ChatRecord | undefined {
-  const supported = /^(message\.(start|delta|interim|complete)|(?:reasoning|thinking)\.(delta|complete)|tool\.|run\.(completed|failed)|error$)/.test(type)
-  if (!supported) return undefined
-  // Parameter-generation notifications have no invocation identity. They are
-  // progress text, not an additional tool call which can later complete.
-  if (type.startsWith('tool.') && !String(payload.tool_id ?? payload.tool_call_id ?? payload.id ?? '').trim()) return undefined
-  const supplied = payload.message && typeof payload.message === 'object' ? payload.message : {}
-  const id = String(supplied.id ?? payload.message_id ?? previous?.id ?? fallbackID)
-  const message: ChatRecord = { role: 'assistant', content: '', reasoning: '', timestamp: now / 1000,
-    ...previous, ...supplied, id }
-  if (type === 'message.delta') message.content = String(message.content ?? '') + text(payload)
-  if (type === 'message.interim') {
-    if (typeof payload.text === 'string') message.content = payload.text
-    else if (typeof payload.content === 'string') message.content = payload.content
-    message.status = 'complete'
-  }
-  if (type === 'reasoning.delta' || type === 'thinking.delta') message.reasoning = String(message.reasoning ?? '') + text(payload)
-  if (type === 'reasoning.complete' || type === 'thinking.complete') {
-    const reasoning = payload.reasoning ?? payload.text ?? payload.content
-    if (typeof reasoning === 'string') message.reasoning = reasoning
-  }
-  if (type.startsWith('tool.')) {
-    const tools: ChatRecord[] = Array.isArray(message.tool_calls) ? [...message.tool_calls] : []
-    const toolID = String(payload.tool_id ?? payload.tool_call_id ?? payload.id ?? '')
-    const index = tools.findIndex(t => t.id === toolID)
-    const value = { ...(index >= 0 ? tools[index] : {}), ...payload, id: toolID,
-      status: toolStatus(type, payload.result ?? payload.output, payload.error) }
-    if (index >= 0) tools[index] = value; else tools.push(value)
-    message.tool_calls = tools
-  }
-  if (type === 'message.complete' || type === 'run.completed') {
-    if (typeof payload.output === 'string') message.content = payload.output
-    else if (typeof payload.content === 'string') message.content = payload.content
-    else if (typeof payload.text === 'string') message.content = payload.text
-    message.status = ['interrupted','cancelled','canceled'].includes(payload.status) ? 'interrupted'
-      : payload.error || ['error','failed'].includes(payload.status) ? 'failed' : 'complete'
-    if(payload.error)message.error=payload.error
-  } else if (type === 'error' || type === 'run.failed') {
-    message.status = 'failed'; message.error = String(payload.error ?? payload.message ?? '运行失败')
-  } else if (type !== 'message.interim' && !(type.startsWith('tool.') && ['complete', 'failed'].includes(previous?.status))) message.status = 'streaming'
-  message.final_result = type.startsWith('tool.') && previous?.final_result === true
-    || (type === 'message.complete' || type === 'run.completed') && message.status === 'complete'
-  if (['message.complete', 'run.completed', 'run.failed', 'error'].includes(type)) {
-    message.tool_calls = (message.tool_calls ?? []).filter((tool: ChatRecord) => tool.id).map((tool: ChatRecord) => ({
-      ...tool, status: toolStatus(tool.status, tool.result, tool.error) === 'running' ? 'completed' : toolStatus(tool.status, tool.result, tool.error),
-      ...(toolStatus(tool.status, tool.result, tool.error) === 'running' ? { completion_unknown: true } : {}),
-    }))
-  }
-  return message
-}

+ 8 - 7
src/server/chatTranscriptApi.ts

@@ -21,10 +21,8 @@ export function chatTranscriptRouter(cache:ChatCacheCoordinator,auth:LocalAuthSt
     const {owner,profile,id}=scope(ctx)
     const before=ctx.query.before===undefined?Number.MAX_SAFE_INTEGER:Number(ctx.query.before),limit=ctx.query.limit===undefined?150:Number(ctx.query.limit)
     if(!Number.isSafeInteger(before)||before<1||!Number.isSafeInteger(limit)||limit<1||limit>500)throw new HttpError(400,'历史分页参数无效','invalid_page')
-    const total=Number(JSON.parse(store.localDetail(owner,profile,id)!.response.body.toString()).message_count??0)
-    const offset=before===Number.MAX_SAFE_INTEGER?0:Math.max(0,total-(before-1))
-    if(!store.messagePage(owner,profile,id,offset,before===Number.MAX_SAFE_INTEGER?limit:Math.min(limit,before-1))){cache.schedule(owner,profile,id,true);throw new HttpError(409,'历史正在后台补齐','CHAT_HISTORY_SYNC_PENDING')}
-    cache.readLocal(owner,'messages',profile,id,{limit:1})
+    const coverage=store.db.prepare('SELECT complete FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,id)
+    if(!coverage?.complete||store.needsListMetadata(owner,profile)||store.localDetail(owner,profile,id)?.state==='gap')cache.schedule(owner,profile,id)
     store.db.exec('SAVEPOINT transcript_snapshot')
     try{
       transcripts.seed(owner,profile,id)
@@ -37,7 +35,9 @@ export function chatTranscriptRouter(cache:ChatCacheCoordinator,auth:LocalAuthSt
     const {owner,profile,id}=scope(ctx),version=auth.pushAuthorizationVersion(owner)
     const raw=ctx.get('last-event-id')||String(ctx.query.after??''),parts=raw.split(':')
     let cursor=Number(parts.at(-1)),closed=false,lastFlush=0
-    if(parts.length!==2||parts[0]!==transcripts.epoch||!Number.isSafeInteger(cursor)||cursor<0||cursor>transcripts.cursor(owner,profile,id))throw new HttpError(409,'聊天事件需要重新同步','transcript_reset')
+    transcripts.seed(owner,profile,id)
+    const epoch=transcripts.epochFor(owner,profile,id)
+    if(parts.length!==2||parts[0]!==epoch||!Number.isSafeInteger(cursor)||cursor<0||cursor>transcripts.cursor(owner,profile,id))throw new HttpError(409,'聊天事件需要重新同步','transcript_reset')
     const res=ctx.res
     let timer:ReturnType<typeof setTimeout>|undefined,heartbeat:ReturnType<typeof setInterval>|undefined,off=()=>{}
     const valid=()=>!store.isClosed&&auth.isUserActive(owner)&&auth.pushAuthorizationVersion(owner)===version&&auth.current(ctx)?.id===owner&&store.ownsSession(owner,profile,id)&&auth.canUseSource(owner,'local',profile)
@@ -50,8 +50,9 @@ export function chatTranscriptRouter(cache:ChatCacheCoordinator,auth:LocalAuthSt
     const flush=()=>{
       clearTimeout(timer);timer=undefined
       if(!valid()){close();return}
+      if(transcripts.epochFor(owner,profile,id)!==epoch){write('event: reset\ndata: {}\n\n');close();return}
       const events=transcripts.events(owner,profile,id,cursor)
-      for(const event of events){if(!write(`id: ${transcripts.epoch}:${event.cursor}\nevent: transcript\ndata: ${JSON.stringify(event)}\n\n`))return;cursor=event.cursor}
+      for(const event of events){if(event.epoch!==epoch){write('event: reset\ndata: {}\n\n');close();return}if(!write(`id: ${epoch}:${event.cursor}\nevent: transcript\ndata: ${JSON.stringify(event)}\n\n`))return;cursor=event.cursor}
       if(events.length)lastFlush=Date.now()
       if(events.length===250)timer=setTimeout(flush,0)
     }
@@ -66,7 +67,7 @@ export function chatTranscriptRouter(cache:ChatCacheCoordinator,auth:LocalAuthSt
     res.writeHead(200,{'Content-Type':'text/event-stream; charset=utf-8','Cache-Control':'no-store','X-Accel-Buffering':'no'})
     res.flushHeaders();res.once('close',close);res.once('error',close)
     off=transcripts.subscribe(changed)
-    flush();write(`event: ready\ndata: ${JSON.stringify({epoch:transcripts.epoch,cursor})}\n\n`)
+    flush();write(`event: ready\ndata: ${JSON.stringify({epoch,cursor})}\n\n`)
     heartbeat=setInterval(()=>{if(valid())write(': heartbeat\n\n');else close()},15_000);heartbeat.unref()
   })
   return router

+ 1065 - 113
src/server/chatTranscriptStore.ts

@@ -1,16 +1,62 @@
 import { randomUUID } from 'node:crypto'
 import type { DatabaseSync } from 'node:sqlite'
-import { CHAT_TRANSCRIPT_FEATURE, type TranscriptEvent, type TranscriptMessage, type TranscriptSnapshot } from '../shared/chatTranscript.js'
+import {
+  CHAT_TRANSCRIPT_FEATURE,
+  type TranscriptEvent,
+  type TranscriptMessage,
+  type TranscriptSnapshot,
+} from '../shared/chatTranscript.js'
+import { toolStatus } from '../shared/chatTools.js'
+import { isFinalChatResult } from './chatUnread.js'
 
-/** A versioned display projection and replay log in the chat cache transaction. */
+type Scope = [string, string, string]
+type Data = Record<string, any>
+interface TurnHead {
+  turn?: string
+  current?: string
+  preview?: boolean
+  terminal?: boolean
+  running: boolean
+  queued: boolean
+  queue: Array<{ turn: string; user: string; delivery: string }>
+  tools: Record<string, string>
+  pending: Record<string, { user: string; turn: string; previousRunning: boolean }>
+  pendingApproval?: Data | null
+  pendingClarification?: Data | null
+  liveStatus?: string | null
+  resyncing?: boolean
+  error?: string | null
+  stagedAttachments?: Data[]
+  localReadEstablished?: boolean
+  importedReadPosition?: number
+}
+const emptyHead = (): TurnHead => ({ running: false, queued: false, queue: [], tools: {}, pending: {} })
+const text = (p: Data): string => String(p.output ?? p.text ?? p.content ?? '')
+const controlState = (head: TurnHead) => ({
+  running: head.running,
+  queued: head.queued,
+  pendingApproval: head.pendingApproval ?? null,
+  pendingClarification: head.pendingClarification ?? null,
+  liveStatus: head.liveStatus ?? null,
+  error: head.error ?? null,
+})
+
+/** The sole ordinary-chat writer. Raw history is an import source, never a live projection. */
 export class ChatTranscriptStore {
-  // Opt in until the three clients finish end-to-end transcript validation.
-  readonly enabled = process.env.HERMES_YAOYAO_ORDINARY_TRANSCRIPTS === '1'
+  readonly enabled = true
   readonly epoch: string
   private listeners = new Set<() => void>()
   private scheduled = false
   private closed = false
-  constructor(readonly db: DatabaseSync,readonly enrich:(owner:string,profile:string,sessionId:string,rows:Record<string,any>[])=>Record<string,any>[] = (_o,_p,_s,rows)=>rows) {
+  constructor(
+    readonly db: DatabaseSync,
+    readonly enrich: (
+      owner: string,
+      profile: string,
+      sessionId: string,
+      rows: Record<string, any>[],
+    ) => Record<string, any>[] = (_o, _p, _s, rows) => rows,
+  ) {
     db.exec(`CREATE TABLE IF NOT EXISTS chat_transcript_meta(key TEXT PRIMARY KEY,value TEXT NOT NULL);
       CREATE TABLE IF NOT EXISTS chat_transcript_scopes(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,PRIMARY KEY(owner,profile,session_id));
       CREATE TABLE IF NOT EXISTS chat_transcript_execution(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,data TEXT NOT NULL,PRIMARY KEY(owner,profile,session_id));
@@ -23,124 +69,1030 @@ export class ChatTranscriptStore {
       CREATE TABLE IF NOT EXISTS chat_transcript_events(cursor INTEGER PRIMARY KEY AUTOINCREMENT,owner TEXT NOT NULL,
         profile TEXT NOT NULL,session_id TEXT NOT NULL,type TEXT NOT NULL,data TEXT NOT NULL,created_at INTEGER NOT NULL);
       CREATE INDEX IF NOT EXISTS chat_transcript_replay ON chat_transcript_events(owner,profile,session_id,cursor);`)
+    db.exec(`CREATE TABLE IF NOT EXISTS chat_transcript_heads(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,epoch TEXT NOT NULL,data TEXT NOT NULL,
+      PRIMARY KEY(owner,profile,session_id));
+      CREATE TABLE IF NOT EXISTS chat_transcript_archives(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,epoch TEXT NOT NULL,data TEXT NOT NULL,created_at INTEGER NOT NULL,
+      PRIMARY KEY(owner,profile,session_id,epoch));
+      CREATE TABLE IF NOT EXISTS chat_transcript_reads(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,id TEXT NOT NULL,PRIMARY KEY(owner,profile,session_id,id));
+      CREATE TABLE IF NOT EXISTS chat_transcript_source_cursors(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,runtime TEXT NOT NULL,epoch TEXT NOT NULL,seq INTEGER NOT NULL,
+      PRIMARY KEY(owner,profile,session_id,runtime,epoch));
+      CREATE TABLE IF NOT EXISTS chat_transcript_repairs(owner TEXT NOT NULL,profile TEXT NOT NULL,session_id TEXT NOT NULL,status TEXT NOT NULL DEFAULT 'pending',
+      PRIMARY KEY(owner,profile,session_id));`)
     db.prepare("INSERT OR IGNORE INTO chat_transcript_meta VALUES('epoch',?)").run(randomUUID())
     this.epoch = String(db.prepare("SELECT value FROM chat_transcript_meta WHERE key='epoch'").get()!.value)
   }
-  close() { this.closed=true; this.listeners.clear() }
-  subscribe(listener: () => void) { this.listeners.add(listener); return () => { this.listeners.delete(listener) } }
+  close() {
+    this.closed = true
+    this.listeners.clear()
+  }
+  subscribe(listener: () => void) {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
   private notify() {
     if (this.scheduled || this.closed) return
-    this.scheduled=true
+    this.scheduled = true
     // All enclosing cache savepoints finish synchronously. Read committed log
     // rows in subscribers; a rolled-back notification therefore emits nothing.
-    queueMicrotask(() => { this.scheduled=false; if(!this.closed) for(const listener of this.listeners) { try{listener()}catch{} } })
+    queueMicrotask(() => {
+      this.scheduled = false
+      if (!this.closed)
+        for (const listener of this.listeners) {
+          try {
+            listener()
+          } catch {}
+        }
+    })
   }
-  private event(owner:string,profile:string,sessionId:string,type:TranscriptEvent['type'],data:unknown) {
-    this.db.prepare('INSERT INTO chat_transcript_events(owner,profile,session_id,type,data,created_at) VALUES(?,?,?,?,?,?)')
-      .run(owner,profile,sessionId,type,JSON.stringify(data),Date.now())
+  private event(
+    owner: string,
+    profile: string,
+    sessionId: string,
+    type: TranscriptEvent['type'],
+    data: unknown,
+  ) {
+    const previousCursor = this.cursor(owner, profile, sessionId)
+    const envelope = {
+      data,
+      previousCursor,
+      epoch: this.epochFor(owner, profile, sessionId),
+      total: this.total(owner, profile, sessionId),
+    }
+    this.db
+      .prepare(
+        'INSERT INTO chat_transcript_events(owner,profile,session_id,type,data,created_at) VALUES(?,?,?,?,?,?)',
+      )
+      .run(owner, profile, sessionId, type, JSON.stringify(envelope), Date.now())
     this.notify()
   }
-  private alias(owner:string,profile:string,sessionId:string,key:string):string|undefined {
-    return (this.db.prepare('SELECT id FROM chat_transcript_aliases WHERE owner=? AND profile=? AND session_id=? AND source=?')
-      .get(owner,profile,sessionId,key) as {id:string}|undefined)?.id
-  }
-  promote(owner:string,profile:string,sessionId:string,oldSource:string,newSource:string) {
-    const id=this.alias(owner,profile,sessionId,`source:${oldSource}`)
-    if(id&&!this.alias(owner,profile,sessionId,`source:${newSource}`)) this.db.prepare('INSERT INTO chat_transcript_aliases VALUES(?,?,?,?,?)').run(owner,profile,sessionId,`source:${newSource}`,id)
-  }
-  upsert(owner:string,profile:string,sessionId:string,source:Record<string,any>,position:number) {
-    const sourceID=String(source.id??source.message_id??'')
-    if(!sourceID)return
-    const keys=[`source:${sourceID}`]
-    if(source.role==='user'&&source.client_message_id)keys.unshift(`client:${source.client_message_id}`)
-    if(source.role==='tool'&&source.tool_call_id)keys.unshift(`tool:${source.tool_call_id}`)
-    const id=keys.map(key=>this.alias(owner,profile,sessionId,key)).find(Boolean)??randomUUID()
-    for(const duplicate of new Set(keys.map(key=>this.alias(owner,profile,sessionId,key)).filter((value):value is string=>!!value&&value!==id))){
-      const old=this.db.prepare('SELECT revision,deleted FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND id=?').get(owner,profile,sessionId,duplicate) as {revision:number;deleted:number}|undefined
-      this.db.prepare('UPDATE chat_transcript_aliases SET id=? WHERE owner=? AND profile=? AND session_id=? AND id=?').run(id,owner,profile,sessionId,duplicate)
-      if(old&&!old.deleted){this.db.prepare('UPDATE chat_transcript_messages SET deleted=1,revision=revision+1 WHERE owner=? AND profile=? AND session_id=? AND id=?').run(owner,profile,sessionId,duplicate);this.event(owner,profile,sessionId,'message.deleted',{id:duplicate,revision:old.revision+1})}
-    }
-    const row=this.db.prepare('SELECT data,revision,deleted FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND id=?')
-      .get(owner,profile,sessionId,id) as {data:string;revision:number;deleted:number}|undefined
-    const old:TranscriptMessage|undefined=row?JSON.parse(row.data):undefined
-    const next:TranscriptMessage={...source,id,source_message_id:sourceID,seq:position+1,revision:row?.revision??0,
-      role:String(source.role??'assistant'),content:source.content??'',reasoning:String(source.reasoning??source.reasoning_content??'')}
-    if(!next.client_message_id&&old?.client_message_id)next.client_message_id=old.client_message_id
-    for(const key of keys)this.db.prepare('INSERT INTO chat_transcript_aliases VALUES(?,?,?,?,?) ON CONFLICT(owner,profile,session_id,source) DO UPDATE SET id=excluded.id').run(owner,profile,sessionId,key,id)
-    if(old&&!row?.deleted&&JSON.stringify(old)===JSON.stringify(next))return
+  private alias(owner: string, profile: string, sessionId: string, key: string): string | undefined {
+    return (
+      this.db
+        .prepare(
+          'SELECT id FROM chat_transcript_aliases WHERE owner=? AND profile=? AND session_id=? AND source=?',
+        )
+        .get(owner, profile, sessionId, key) as { id: string } | undefined
+    )?.id
+  }
+  promote(owner: string, profile: string, sessionId: string, oldSource: string, newSource: string) {
+    const id = this.alias(owner, profile, sessionId, `source:${oldSource}`)
+    if (id && !this.alias(owner, profile, sessionId, `source:${newSource}`))
+      this.db
+        .prepare('INSERT INTO chat_transcript_aliases VALUES(?,?,?,?,?)')
+        .run(owner, profile, sessionId, `source:${newSource}`, id)
+  }
+  upsert(
+    owner: string,
+    profile: string,
+    sessionId: string,
+    source: Record<string, any>,
+    position: number,
+  ): TranscriptMessage | undefined {
+    const sourceID = String(source.id ?? source.message_id ?? '')
+    if (!sourceID) return
+    const keys = [`source:${sourceID}`]
+    if (source.role === 'user' && source.client_message_id) keys.unshift(`client:${source.client_message_id}`)
+    if (source.role === 'tool' && source.tool_call_id)
+      keys.unshift(`tool:${source.turn_id ?? ''}:${source.tool_call_id}`)
+    const id =
+      this.message(owner, profile, sessionId, sourceID)?.id ??
+      keys.map((key) => this.alias(owner, profile, sessionId, key)).find(Boolean) ??
+      randomUUID()
+    for (const duplicate of new Set(
+      keys
+        .map((key) => this.alias(owner, profile, sessionId, key))
+        .filter((value): value is string => !!value && value !== id),
+    )) {
+      const old = this.db
+        .prepare(
+          'SELECT revision,deleted FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND id=?',
+        )
+        .get(owner, profile, sessionId, duplicate) as { revision: number; deleted: number } | undefined
+      this.db
+        .prepare(
+          'UPDATE chat_transcript_aliases SET id=? WHERE owner=? AND profile=? AND session_id=? AND id=?',
+        )
+        .run(id, owner, profile, sessionId, duplicate)
+      if (old && !old.deleted) {
+        this.db
+          .prepare(
+            'UPDATE chat_transcript_messages SET deleted=1,revision=revision+1 WHERE owner=? AND profile=? AND session_id=? AND id=?',
+          )
+          .run(owner, profile, sessionId, duplicate)
+        this.event(owner, profile, sessionId, 'message.deleted', {
+          id: duplicate,
+          revision: old.revision + 1,
+        })
+      }
+    }
+    const row = this.db
+      .prepare(
+        'SELECT data,revision,deleted FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND id=?',
+      )
+      .get(owner, profile, sessionId, id) as { data: string; revision: number; deleted: number } | undefined
+    const old: TranscriptMessage | undefined = row ? JSON.parse(row.data) : undefined
+    const next: TranscriptMessage = {
+      ...source,
+      id,
+      source_message_id: source.source_message_id ?? old?.source_message_id ?? sourceID,
+      seq: old?.seq ?? position + 1,
+      revision: row?.revision ?? 0,
+      role: String(source.role ?? 'assistant'),
+      content: source.content ?? '',
+      reasoning: String(source.reasoning ?? source.reasoning_content ?? ''),
+    }
+    if (!next.client_message_id && old?.client_message_id) next.client_message_id = old.client_message_id
+    for (const key of keys)
+      this.db
+        .prepare(
+          'INSERT INTO chat_transcript_aliases VALUES(?,?,?,?,?) ON CONFLICT(owner,profile,session_id,source) DO UPDATE SET id=excluded.id',
+        )
+        .run(owner, profile, sessionId, key, id)
+    if (old && !row?.deleted && JSON.stringify(old) === JSON.stringify(next)) return old
     next.revision++
-    this.db.prepare('INSERT INTO chat_transcript_messages VALUES(?,?,?,?,?,?,?,0) ON CONFLICT(owner,profile,session_id,id) DO UPDATE SET seq=excluded.seq,revision=excluded.revision,data=excluded.data,deleted=0')
-      .run(owner,profile,sessionId,id,next.seq,next.revision,JSON.stringify(next))
-    let patch:Record<string,unknown>|undefined
-    if(old&&!row?.deleted&&old.status==='streaming'&&next.status==='streaming'&&typeof old.content==='string'&&typeof next.content==='string'
-      &&next.content.startsWith(old.content)&&next.reasoning!.startsWith(String(old.reasoning??''))){
-      const {content:a,reasoning:b,revision:c,...oldMeta}=old
-      const {content:d,reasoning:e,revision:f,...newMeta}=next
-      if(JSON.stringify(oldMeta)===JSON.stringify(newMeta))patch={id,seq:next.seq,baseRevision:old.revision,revision:next.revision,
-        contentAppend:next.content.slice(old.content.length),reasoningAppend:next.reasoning!.slice(String(old.reasoning??'').length)}
-    }
-    this.event(owner,profile,sessionId,patch?'message.patch':'message.upsert',patch??next)
-  }
-  reconcile(owner:string,profile:string,sessionId:string) {
-    const rows=this.db.prepare('SELECT data,position FROM chat_messages WHERE owner=? AND profile=? AND session_id=? ORDER BY position').all(owner,profile,sessionId) as {data:string;position:number}[]
-    const live=new Set<string>()
-    const enriched=this.enrich(owner,profile,sessionId,rows.map(row=>JSON.parse(row.data)))
-    for(const [index,row] of rows.entries()){const source=enriched[index]!;this.upsert(owner,profile,sessionId,source,row.position);const id=this.alias(owner,profile,sessionId,`source:${source.id??source.message_id}`);if(id)live.add(id)}
-    for(const row of this.db.prepare('SELECT id,revision FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0').all(owner,profile,sessionId) as {id:string;revision:number}[]){
-      if(live.has(row.id))continue
-      this.db.prepare('UPDATE chat_transcript_messages SET deleted=1,revision=revision+1 WHERE owner=? AND profile=? AND session_id=? AND id=?').run(owner,profile,sessionId,row.id)
-      this.event(owner,profile,sessionId,'message.deleted',{id:row.id,revision:row.revision+1})
-    }
-  }
-  seed(owner:string,profile:string,sessionId:string) {
-    if(this.db.prepare('SELECT 1 FROM chat_transcript_scopes WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,sessionId))return
-    this.reconcile(owner,profile,sessionId)
-    this.db.prepare('INSERT INTO chat_transcript_scopes VALUES(?,?,?)').run(owner,profile,sessionId)
-  }
-  sessionChanged(owner:string,profile:string,sessionId:string,data:Record<string,unknown>) {
-    const row=this.db.prepare('SELECT data FROM chat_transcript_execution WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,sessionId) as {data:string}|undefined
-    const state=row?JSON.parse(row.data):{running:false,queued:false,pending:{}}
-    const p=(data.payload??{}) as Record<string,any>,type=String(data.eventType)
-    state.pending??={}
-    if(type==='command.submitted'){state.pending[p.delivery_id]=state.running;state.queued=state.running;state.running=true}
-    if(type==='command.confirmed'||type==='command.rejected'){
-      if(type==='command.rejected')state.running=state.pending[p.delivery_id]??state.running
-      else{state.running=true;state.queued=p.status==='queued'}
-      delete state.pending[p.delivery_id]
-    }
-    if(['message.start','run.started','approval.request','clarify.request'].includes(type))state.running=true
-    if(type==='route.resumed'&&typeof p.running==='boolean')state.running=p.running
-    if(['message.complete','run.completed','run.failed','error'].includes(type)){
-      state.queued=Number(p.queue_remaining??p.queueRemaining??0)>0
-      state.running=state.queued||Number(p.background_pending??p.backgroundPending??0)>0
-    }
-    this.db.prepare('INSERT INTO chat_transcript_execution VALUES(?,?,?,?) ON CONFLICT(owner,profile,session_id) DO UPDATE SET data=excluded.data').run(owner,profile,sessionId,JSON.stringify(state))
-    this.event(owner,profile,sessionId,'session.changed',{...data,running:state.running,queued:state.queued})
-  }
-  migrate(owner:string,profile:string,oldID:string,newID:string) {
-    for(const table of ['chat_transcript_messages','chat_transcript_aliases','chat_transcript_scopes','chat_transcript_execution'])this.db.prepare(`UPDATE ${table} SET session_id=? WHERE owner=? AND profile=? AND session_id=?`).run(newID,owner,profile,oldID)
-    this.event(owner,profile,oldID,'session.migrated',{sessionId:newID})
-  }
-  remove(owner:string,profile:string,sessionId:string) {
-    this.event(owner,profile,sessionId,'session.deleted',{sessionId})
-    for(const table of ['chat_transcript_messages','chat_transcript_aliases','chat_transcript_scopes','chat_transcript_execution'])this.db.prepare(`DELETE FROM ${table} WHERE owner=? AND profile=? AND session_id=?`).run(owner,profile,sessionId)
-  }
-  cursor(owner:string,profile:string,sessionId:string):number {
-    return Number(this.db.prepare('SELECT COALESCE(MAX(cursor),0) cursor FROM chat_transcript_events WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,sessionId)!.cursor)
-  }
-  events(owner:string,profile:string,sessionId:string,after:number,limit=250):TranscriptEvent[] {
-    return (this.db.prepare('SELECT cursor,type,data FROM chat_transcript_events WHERE owner=? AND profile=? AND session_id=? AND cursor>? ORDER BY cursor LIMIT ?').all(owner,profile,sessionId,after,limit) as {cursor:number;type:TranscriptEvent['type'];data:string}[])
-      .map(row=>({...row,profile,sessionId,data:JSON.parse(row.data)}))
-  }
-  snapshot(owner:string,profile:string,sessionId:string,session:Record<string,unknown>,state:string,before=Number.MAX_SAFE_INTEGER,limit=150):TranscriptSnapshot {
-    const execution=this.db.prepare('SELECT data FROM chat_transcript_execution WHERE owner=? AND profile=? AND session_id=?').get(owner,profile,sessionId) as {data:string}|undefined
-    const run=execution?JSON.parse(execution.data):{}
-    const rows=this.db.prepare('SELECT data FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0 AND seq<? ORDER BY seq DESC,id DESC LIMIT ?')
-      .all(owner,profile,sessionId,before,limit+1) as {data:string}[]
-    return {protocol:CHAT_TRANSCRIPT_FEATURE,epoch:this.epoch,cursor:this.cursor(owner,profile,sessionId),profile,sessionId,running:run.running,queued:run.queued,
-      messages:rows.slice(0,limit).reverse().map(row=>JSON.parse(row.data)),session,state,
-      deletedIds:(this.db.prepare('SELECT id FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=1').all(owner,profile,sessionId) as {id:string}[]).map(row=>row.id),
-      hasOlder:rows.length>limit||(rows.length>0&&Number(JSON.parse(rows[Math.min(limit,rows.length)-1]!.data).seq)>1),
-      total:Number(this.db.prepare('SELECT COUNT(*) n FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0').get(owner,profile,sessionId)!.n)}
+    this.db
+      .prepare(
+        'INSERT INTO chat_transcript_messages VALUES(?,?,?,?,?,?,?,0) ON CONFLICT(owner,profile,session_id,id) DO UPDATE SET seq=excluded.seq,revision=excluded.revision,data=excluded.data,deleted=0',
+      )
+      .run(owner, profile, sessionId, id, next.seq, next.revision, JSON.stringify(next))
+    let patch: Record<string, unknown> | undefined
+    if (
+      old &&
+      !row?.deleted &&
+      old.status === 'streaming' &&
+      next.status === 'streaming' &&
+      typeof old.content === 'string' &&
+      typeof next.content === 'string' &&
+      next.content.startsWith(old.content) &&
+      next.reasoning!.startsWith(String(old.reasoning ?? ''))
+    ) {
+      const { content: a, reasoning: b, revision: c, ...oldMeta } = old
+      const { content: d, reasoning: e, revision: f, ...newMeta } = next
+      if (JSON.stringify(oldMeta) === JSON.stringify(newMeta))
+        patch = {
+          id,
+          seq: next.seq,
+          baseRevision: old.revision,
+          revision: next.revision,
+          contentAppend: next.content.slice(old.content.length),
+          reasoningAppend: next.reasoning!.slice(String(old.reasoning ?? '').length),
+        }
+    }
+    this.event(owner, profile, sessionId, patch ? 'message.patch' : 'message.upsert', patch ?? next)
+    return next
+  }
+  reconcile(owner: string, profile: string, sessionId: string) {
+    const scope: Scope = [owner, profile, sessionId]
+    this.seed(...scope)
+    if (this.head(...scope).running) throw new Error('Conversation is running; defer history repair')
+    this.importHistory(scope, true)
+  }
+  seed(owner: string, profile: string, sessionId: string) {
+    const scope: Scope = [owner, profile, sessionId]
+    if (
+      this.db
+        .prepare('SELECT 1 FROM chat_transcript_heads WHERE owner=? AND profile=? AND session_id=?')
+        .get(...scope)
+    )
+      return
+    this.db.exec('SAVEPOINT transcript_seed')
+    try {
+      this.archive(scope)
+      // v1 records were projections of the legacy writer. Preserve their source
+      // for verification; do not mix their IDs/checkpoints with a v2 generation.
+      for (const table of [
+        'chat_transcript_messages',
+        'chat_transcript_aliases',
+        'chat_transcript_execution',
+      ])
+        this.db.prepare(`DELETE FROM ${table} WHERE owner=? AND profile=? AND session_id=?`).run(...scope)
+      this.db
+        .prepare('INSERT INTO chat_transcript_heads VALUES(?,?,?,?,?)')
+        .run(...scope, randomUUID(), JSON.stringify(emptyHead()))
+      this.db.prepare('INSERT OR IGNORE INTO chat_transcript_scopes VALUES(?,?,?)').run(...scope)
+      this.importHistory(scope, false)
+      const active = this.all(...scope)
+        .reverse()
+        .find((m) => m.status === 'streaming' && m.role === 'assistant')
+      if (active)
+        this.db
+          .prepare('UPDATE chat_transcript_heads SET data=? WHERE owner=? AND profile=? AND session_id=?')
+          .run(
+            JSON.stringify({ ...emptyHead(), turn: active.turn_id, current: active.id, running: true }),
+            ...scope,
+          )
+      if (this.total(...scope))
+        this.db
+          .prepare('INSERT OR IGNORE INTO chat_transcript_repairs VALUES(?,?,?,?)')
+          .run(...scope, 'pending')
+      this.db.exec('RELEASE transcript_seed')
+    } catch (error) {
+      this.db.exec('ROLLBACK TO transcript_seed; RELEASE transcript_seed')
+      throw error
+    }
+  }
+  sessionChanged(owner: string, profile: string, sessionId: string, data: Record<string, unknown>) {
+    this.reduce(owner, profile, sessionId, String(data.eventType), (data.payload ?? {}) as Data)
+  }
+  epochFor(...scope: Scope): string {
+    return String(
+      this.db
+        .prepare('SELECT epoch FROM chat_transcript_heads WHERE owner=? AND profile=? AND session_id=?')
+        .get(...scope)?.epoch ?? this.epoch,
+    )
+  }
+  head(...scope: Scope): TurnHead {
+    const row = this.db
+      .prepare('SELECT data FROM chat_transcript_heads WHERE owner=? AND profile=? AND session_id=?')
+      .get(...scope)
+    return row ? JSON.parse(String(row.data)) : emptyHead()
+  }
+  message(owner: string, profile: string, sessionId: string, id: string): TranscriptMessage | undefined {
+    const row = this.db
+      .prepare(
+        'SELECT data FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND id=? AND deleted=0',
+      )
+      .get(owner, profile, sessionId, id)
+    return row ? JSON.parse(String(row.data)) : undefined
+  }
+  resolveMessage(
+    owner: string,
+    profile: string,
+    sessionId: string,
+    id: string,
+  ): TranscriptMessage | undefined {
+    return (
+      this.message(owner, profile, sessionId, id) ??
+      this.message(owner, profile, sessionId, this.alias(owner, profile, sessionId, `source:${id}`) ?? '')
+    )
+  }
+  all(...scope: Scope): TranscriptMessage[] {
+    return this.db
+      .prepare(
+        'SELECT data FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0 ORDER BY seq,id',
+      )
+      .all(...scope)
+      .map((row) => JSON.parse(String(row.data)))
+  }
+  total(...scope: Scope): number {
+    return Number(
+      this.db
+        .prepare(
+          'SELECT COUNT(*) n FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0',
+        )
+        .get(...scope)!.n,
+    )
+  }
+  private put(scope: Scope, value: Data): TranscriptMessage {
+    const position = Number(
+      this.db
+        .prepare(
+          'SELECT COALESCE(MAX(seq),0) n FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=?',
+        )
+        .get(...scope)!.n,
+    )
+    return this.upsert(
+      ...scope,
+      { timestamp: Date.now() / 1000, ...value, id: value.id ?? randomUUID() },
+      position,
+    )!
+  }
+  private bind(scope: Scope, source: string, id: string) {
+    if (source)
+      this.db
+        .prepare(
+          'INSERT INTO chat_transcript_aliases VALUES(?,?,?,?,?) ON CONFLICT(owner,profile,session_id,source) DO UPDATE SET id=excluded.id',
+        )
+        .run(...scope, `source:${source}`, id)
+  }
+  archive(scope: Scope) {
+    const data = {
+      messages: this.all(...scope),
+      head: this.head(...scope),
+      rawMessages: this.db
+        .prepare(
+          'SELECT message_id,position,data FROM chat_messages WHERE owner=? AND profile=? AND session_id=? ORDER BY position',
+        )
+        .all(...scope),
+      aliases: this.db
+        .prepare('SELECT source,id FROM chat_transcript_aliases WHERE owner=? AND profile=? AND session_id=?')
+        .all(...scope),
+    }
+    if (data.messages.length || data.rawMessages.length)
+      this.db
+        .prepare('INSERT OR IGNORE INTO chat_transcript_archives VALUES(?,?,?,?,?,?)')
+        .run(...scope, this.epochFor(...scope), JSON.stringify(data), Date.now())
+  }
+  private importHistory(scope: Scope, verified: boolean) {
+    if (verified) this.archive(scope)
+    const raw = this.db
+      .prepare(
+        'SELECT data,position FROM chat_messages WHERE owner=? AND profile=? AND session_id=? ORDER BY position',
+      )
+      .all(...scope) as { data: string; position: number }[]
+    const incoming = this.enrich(
+      ...scope,
+      raw.map((row) => JSON.parse(row.data)),
+    )
+    const existing = this.all(...scope),
+      retained = new Set<string>(),
+      wasRead = new Set(
+        this.db
+          .prepare('SELECT id FROM chat_transcript_reads WHERE owner=? AND profile=? AND session_id=?')
+          .all(...scope)
+          .map((row) => String(row.id)),
+      )
+    if (
+      verified &&
+      existing.some(
+        (m) =>
+          m.role === 'user' &&
+          m.status === 'complete' &&
+          m.client_message_id &&
+          m.source_message_id.startsWith('user:') &&
+          !incoming.some(
+            (source) =>
+              source.role === 'user' &&
+              (source.client_message_id === m.client_message_id ||
+                String(source.id ?? source.message_id) === m.source_message_id),
+          ),
+      )
+    ) {
+      this.db
+        .prepare(
+          "INSERT INTO chat_transcript_repairs VALUES(?,?,?,'pending') ON CONFLICT(owner,profile,session_id) DO UPDATE SET status='pending'",
+        )
+        .run(...scope)
+      return // The archive is available for verification; ambiguous live turns remain untouched.
+    }
+    const legacyRead = this.db
+      .prepare(
+        'SELECT COALESCE(final_read_count,read_count) n,read_initialized FROM chat_local_state WHERE owner=? AND profile=? AND session_id=?',
+      )
+      .get(...scope)
+    const boundary = legacyRead?.read_initialized ? Number(legacyRead.n) : Infinity
+    let turn = 'history:orphan',
+      ordinal = 0
+    for (const [index, source] of incoming.entries()) {
+      const sourceID = String(source.id ?? source.message_id ?? raw[index]!.position)
+      let known = this.resolveMessage(...scope, sourceID)
+      if (source.role === 'user' && source.client_message_id)
+        known ??= existing.find((m) => m.client_message_id === source.client_message_id)
+      if (source.role === 'user') turn = known?.turn_id ?? `history:${sourceID}`
+      const nextUser = incoming.findIndex((m, i) => i > index && m.role === 'user')
+      const rest = incoming.slice(index + 1, nextUser < 0 ? undefined : nextUser)
+      const final =
+        isFinalChatResult(source) &&
+        (source.final_result === true || !rest.some((message) => isFinalChatResult(message)))
+      // Only a proven user identity can associate an upstream final with the
+      // one live final of that turn. Content similarity is never an identity.
+      if (!known && verified && final) {
+        const candidates = existing.filter(
+          (m) => m.turn_id === turn && m.final_result === true && !retained.has(m.id),
+        )
+        if (candidates.length === 1) known = candidates[0]
+      }
+      const value = this.upsert(
+        ...scope,
+        {
+          ...source,
+          id: known?.id ?? sourceID,
+          source_message_id: sourceID,
+          turn_id: turn,
+          segment_kind:
+            source.role === 'user'
+              ? 'input'
+              : source.role === 'tool'
+                ? 'tool'
+                : final
+                  ? 'answer'
+                  : 'commentary',
+          final_result: final,
+        },
+        verified ? ordinal++ : raw[index]!.position,
+      )!
+      this.bind(scope, sourceID, value.id)
+      retained.add(value.id)
+      if (wasRead.has(known?.id ?? '') || raw[index]!.position < boundary)
+        this.db.prepare('INSERT OR IGNORE INTO chat_transcript_reads VALUES(?,?,?,?)').run(...scope, value.id)
+    }
+    if (!verified) return
+    // An unconfirmed local send is not disproven by a history snapshot.
+    for (const message of existing)
+      if (message.role === 'user' && message.status === 'pending') retained.add(message.id)
+    let structural = [...retained].some((id) => !existing.some((message) => message.id === id))
+    for (const message of existing)
+      if (!retained.has(message.id)) {
+        structural = true
+        this.db
+          .prepare(
+            'UPDATE chat_transcript_messages SET deleted=1,revision=revision+1 WHERE owner=? AND profile=? AND session_id=? AND id=?',
+          )
+          .run(...scope, message.id)
+        this.event(...scope, 'message.deleted', { id: message.id, revision: message.revision + 1 })
+      }
+    // Rebuild order only at an explicit generation boundary. Old pages/events
+    // cannot be merged into this generation, even while a client is paging.
+    const ordered = [...retained]
+    for (const [index, id] of ordered.entries()) {
+      const message = this.message(...scope, id)!
+      if (message.seq !== index + 1) {
+        structural = true
+        this.db
+          .prepare(
+            'UPDATE chat_transcript_messages SET seq=?,revision=revision+1,data=? WHERE owner=? AND profile=? AND session_id=? AND id=?',
+          )
+          .run(
+            index + 1,
+            JSON.stringify({ ...message, seq: index + 1, revision: message.revision + 1 }),
+            ...scope,
+            id,
+          )
+      }
+    }
+    if (structural) {
+      this.db
+        .prepare('UPDATE chat_transcript_heads SET epoch=? WHERE owner=? AND profile=? AND session_id=?')
+        .run(randomUUID(), ...scope)
+      this.event(...scope, 'session.changed', {
+        eventType: 'history.rebuilt',
+        ...controlState(this.head(...scope)),
+      })
+    }
+    this.db
+      .prepare(
+        "UPDATE chat_transcript_repairs SET status='complete' WHERE owner=? AND profile=? AND session_id=?",
+      )
+      .run(...scope)
+  }
+  markRead(owner: string, profile: string, sessionId: string, count = Infinity) {
+    const head = this.head(owner, profile, sessionId)
+    head.localReadEstablished = true
+    this.db
+      .prepare('UPDATE chat_transcript_heads SET data=? WHERE owner=? AND profile=? AND session_id=?')
+      .run(JSON.stringify(head), owner, profile, sessionId)
+    for (const m of this.all(owner, profile, sessionId))
+      if (m.seq <= count && isFinalChatResult(m))
+        this.db
+          .prepare('INSERT OR IGNORE INTO chat_transcript_reads VALUES(?,?,?,?)')
+          .run(owner, profile, sessionId, m.id)
+  }
+  unread(...scope: Scope): number {
+    // Legacy read cursors can finish importing after the initial local snapshot.
+    // Map only persisted source rows, never consume a live streaming result.
+    const legacy = this.db
+      .prepare(
+        'SELECT COALESCE(final_read_count,read_count) n FROM chat_local_state WHERE owner=? AND profile=? AND session_id=? AND read_initialized=1',
+      )
+      .get(...scope)
+    const head = this.head(...scope)
+    if (legacy && !head.localReadEstablished && Number(legacy.n) > (head.importedReadPosition ?? -1)) {
+      for (const row of this.db
+        .prepare(
+          'SELECT message_id FROM chat_messages WHERE owner=? AND profile=? AND session_id=? AND position<?',
+        )
+        .all(...scope, Number(legacy.n))) {
+        const m = this.resolveMessage(...scope, String(row.message_id))
+        if (m && isFinalChatResult(m))
+          this.db.prepare('INSERT OR IGNORE INTO chat_transcript_reads VALUES(?,?,?,?)').run(...scope, m.id)
+      }
+      head.importedReadPosition = Number(legacy.n)
+      this.db
+        .prepare('UPDATE chat_transcript_heads SET data=? WHERE owner=? AND profile=? AND session_id=?')
+        .run(JSON.stringify(head), ...scope)
+    }
+    return this.db
+      .prepare(
+        `SELECT m.data FROM chat_transcript_messages m LEFT JOIN chat_transcript_reads r USING(owner,profile,session_id,id)
+      WHERE m.owner=? AND m.profile=? AND m.session_id=? AND m.deleted=0 AND r.id IS NULL AND json_extract(m.data,'$.final_result')=1`,
+      )
+      .all(...scope)
+      .filter((row) => isFinalChatResult(JSON.parse(String(row.data)))).length
+  }
+  sourceCursor(owner: string, profile: string, sessionId: string, runtime: string, epoch: string): number {
+    return Number(
+      this.db
+        .prepare(
+          'SELECT seq FROM chat_transcript_source_cursors WHERE owner=? AND profile=? AND session_id=? AND runtime=? AND epoch=?',
+        )
+        .get(owner, profile, sessionId, runtime, epoch)?.seq ?? 0,
+    )
+  }
+  recordSource(scope: Scope, frame: Data) {
+    if (frame.epoch && frame.session_id && Number.isSafeInteger(frame.seq))
+      this.db
+        .prepare(
+          'INSERT INTO chat_transcript_source_cursors VALUES(?,?,?,?,?,?) ON CONFLICT(owner,profile,session_id,runtime,epoch) DO UPDATE SET seq=MAX(seq,excluded.seq)',
+        )
+        .run(...scope, frame.session_id, frame.epoch, frame.seq)
+  }
+
+  /** Caller holds the transaction containing the input receipt and raw event. */
+  reduce(owner: string, profile: string, sessionId: string, type: string, p: Data) {
+    type =
+      (
+        {
+          'message.started': 'message.start',
+          'message.completed': 'message.complete',
+          'run.complete': 'run.completed',
+          'reasoning.completed': 'reasoning.complete',
+          'peer.user.message': 'message.user',
+          peer_user_message: 'message.user',
+          'run.peer_user_message': 'message.user',
+        } as Record<string, string>
+      )[type] ?? type
+    const scope: Scope = [owner, profile, sessionId]
+    this.seed(...scope)
+    const state = this.head(...scope)
+    const before = JSON.stringify(state)
+    const sourceID = String(p.message_id ?? p.message?.id ?? '')
+    const upstreamRun = String(p.run_id ?? p.runId ?? p.inflight?.run_id ?? '')
+    const knownTurn = upstreamRun ? this.alias(...scope, `source:turn:${upstreamRun}`) : undefined
+    if (
+      knownTurn &&
+      (knownTurn !== state.turn || state.terminal) &&
+      ['run.started', 'run.start', 'message.start'].includes(type)
+    )
+      return
+    const known =
+      (sourceID ? this.resolveMessage(...scope, sourceID) : undefined) ??
+      (knownTurn && knownTurn !== state.turn
+        ? this.all(...scope)
+            .reverse()
+            .find((m) => m.turn_id === knownTurn && m.role === 'assistant')
+        : undefined)
+    if (
+      known &&
+      state.turn &&
+      known.turn_id !== state.turn &&
+      ['message.complete', 'run.completed', 'message.delta', 'message.interim'].includes(type)
+    ) {
+      const terminal = ['message.complete', 'run.completed'].includes(type)
+      this.put(scope, {
+        ...known,
+        content:
+          type === 'message.delta'
+            ? String(known.content ?? '') + String(p.delta ?? p.text ?? '')
+            : text(p) || known.content,
+        ...(terminal ? { status: 'complete', final_result: true } : {}),
+      })
+      return
+    }
+    const current = () => (state.current ? this.message(...scope, state.current) : undefined)
+    const begin = () => {
+      if (!state.turn || state.terminal) {
+        const queued = state.queue.shift()
+        state.turn = queued?.turn ?? randomUUID()
+        state.current = undefined
+        state.preview = false
+        state.terminal = false
+        state.tools = {}
+        state.error = null
+      }
+      if (upstreamRun) this.bind(scope, `turn:${upstreamRun}`, state.turn!)
+      state.running = true
+      state.queued = state.queue.length > 0
+    }
+    const assistant = (): TranscriptMessage => {
+      begin()
+      const old = current()
+      if (old) return old
+      const created = this.put(scope, {
+        role: 'assistant',
+        turn_id: state.turn,
+        segment_kind: 'answer',
+        content: '',
+        reasoning: '',
+        status: 'streaming',
+        final_result: false,
+      })
+      state.current = created.id
+      return created
+    }
+    const saveAssistant = (value: Data) => {
+      const old = assistant(),
+        source = String(p.message_id ?? p.message?.id ?? '')
+      const attachments = p.attachments ?? p.message?.attachments
+      const saved = this.put(scope, {
+        ...old,
+        ...value,
+        ...(attachments ? { attachments } : {}),
+        ...(source ? { source_message_id: source } : {}),
+      })
+      this.bind(scope, source, saved.id)
+      return saved
+    }
+    if (type === 'command.submitted') {
+      const delivery = String(p.delivery_id),
+        client = String(p.client_message_id ?? delivery.replace(/^(web|ios|android):prompt:/, ''))
+      if (!this.alias(...scope, `client:${client}`)) {
+        const previousRunning = state.running,
+          steer = p.method === 'session.steer' && state.running
+        const turn = steer ? state.turn! : randomUUID()
+        const user = this.put(scope, {
+          id: `user:${delivery}`,
+          role: 'user',
+          turn_id: turn,
+          segment_kind: 'input',
+          client_message_id: client,
+          content: p.text ?? '',
+          status: 'pending',
+          ...(state.stagedAttachments?.length ? { attachments: state.stagedAttachments } : {}),
+        })
+        state.stagedAttachments = []
+        state.error = null
+        state.pending[delivery] = { user: user.id, turn, previousRunning }
+        if (previousRunning && !steer) {
+          state.queue.push({ turn, user: user.id, delivery })
+          state.queued = true
+        } else if (!steer) {
+          state.turn = turn
+          state.current = undefined
+          state.preview = false
+          state.terminal = false
+          state.tools = {}
+        }
+        state.running = true
+      }
+    } else if (type === 'command.confirmed' || type === 'command.rejected') {
+      const pending = state.pending[String(p.delivery_id)]
+      if (pending) {
+        const user = this.message(...scope, pending.user)
+        if (user)
+          this.put(scope, {
+            ...user,
+            status: type === 'command.rejected' ? 'failed' : 'complete',
+            ...(p.error ? { error: p.error } : {}),
+          })
+        if (type === 'command.rejected') {
+          state.queue = state.queue.filter((q) => q.delivery !== p.delivery_id)
+          if (state.turn === pending.turn && !state.current) state.terminal = true
+          state.running = !state.terminal || state.queue.length > 0
+        }
+        delete state.pending[String(p.delivery_id)]
+        state.queued = state.queue.length > 0
+      }
+    } else if (type === 'message.user') {
+      const client = String(p.client_message_id ?? p.queue_id ?? '').replace(/^(web|ios|android):prompt:/, '')
+      const source = String(p.message_id ?? p.id ?? '')
+      const old =
+        (client
+          ? this.all(...scope).find((m) => m.role === 'user' && m.client_message_id === client)
+          : undefined) ?? (source ? this.resolveMessage(...scope, source) : undefined)
+      if (source || client) {
+        const turn = old?.turn_id ?? (p.steer ? state.turn : undefined) ?? randomUUID()
+        const user = this.put(scope, {
+          ...old,
+          id: old?.id || source || randomUUID(),
+          role: 'user',
+          turn_id: turn,
+          segment_kind: 'input',
+          content: p.text ?? p.content ?? '',
+          status: p.status === 'failed' ? 'failed' : 'complete',
+          ...(client ? { client_message_id: client } : {}),
+        })
+        if (!old && p.status !== 'failed') {
+          if (state.running && !p.steer) {
+            state.queue.push({ turn, user: user.id, delivery: client || source })
+            state.queued = true
+          } else if (!p.steer) {
+            state.turn = turn
+            state.current = undefined
+            state.terminal = false
+            state.preview = false
+          }
+        }
+      }
+    } else if (['message.start', 'run.started', 'run.start'].includes(type)) {
+      const old = current()
+      if (
+        type === 'message.start' &&
+        sourceID &&
+        old &&
+        old.source_message_id !== sourceID &&
+        !this.resolveMessage(...scope, sourceID) &&
+        (old.content || old.reasoning || old.tool_calls)
+      ) {
+        this.put(scope, { ...old, status: 'complete', segment_kind: 'commentary', final_result: false })
+        state.current = undefined
+        state.preview = false
+      }
+      const row = assistant()
+      if (sourceID) {
+        this.bind(scope, sourceID, row.id)
+        this.put(scope, { ...row, source_message_id: sourceID })
+      }
+    } else if (['message.delta', 'content.delta', 'assistant.delta'].includes(type) && !state.resyncing) {
+      if (state.preview) {
+        state.current = undefined
+        state.preview = false
+      }
+      const old = assistant()
+      saveAssistant({
+        content:
+          String(old.content ?? '') +
+          String(p.delta ?? p.text_delta ?? p.content_delta ?? p.text ?? p.content ?? ''),
+        status: 'streaming',
+      })
+    } else if (type === 'message.interim') {
+      saveAssistant({
+        content: text(p) || current()?.content || '',
+        status: 'streaming',
+        segment_kind: 'commentary',
+        final_result: false,
+      })
+      state.preview = true
+    } else if (type.startsWith('reasoning.') || type === 'thinking.delta' || type === 'thinking.complete') {
+      const old = assistant(),
+        full = p.reasoning ?? p.text ?? p.content ?? p.delta ?? ''
+      saveAssistant({
+        reasoning: type.endsWith('delta')
+          ? String(old.reasoning ?? '') + String(p.delta ?? full)
+          : String(full),
+      })
+    } else if (type.startsWith('tool.')) {
+      const toolID = String(p.tool_call_id ?? p.tool_id ?? p.id ?? '')
+      if (toolID) {
+        let target = state.tools[toolID] ? this.message(...scope, state.tools[toolID]!) : undefined
+        if (!target && /complete|failed/.test(type)) {
+          const candidates = this.all(...scope).filter((m) =>
+            (m.tool_calls as Data[] | undefined)?.some((t) => t.id === toolID),
+          )
+          if (candidates.length === 1) target = candidates[0]
+        }
+        if (!target) {
+          if (state.preview) {
+            const old = current()
+            if (old) this.put(scope, { ...old, status: 'complete' })
+            state.current = undefined
+            state.preview = false
+          }
+          target = assistant()
+          state.tools[toolID] = target.id
+        }
+        const tools = Array.isArray(target.tool_calls) ? ([...target.tool_calls] as Data[]) : [],
+          index = tools.findIndex((t) => t.id === toolID)
+        const old = index < 0 ? {} : tools[index]!,
+          status = toolStatus(type, p.result ?? p.output, p.error)
+        const tool = {
+          ...old,
+          ...p,
+          id: toolID,
+          status: ['completed', 'failed'].includes(old.status) && status === 'running' ? old.status : status,
+        }
+        if (index < 0) tools.push(tool)
+        else tools[index] = tool
+        this.put(scope, { ...target, tool_calls: tools })
+      } else state.liveStatus = p.name ? `正在准备 ${p.name}` : state.liveStatus
+    } else if (['message.complete', 'run.completed', 'run.complete', 'run.failed', 'error'].includes(type)) {
+      // A replayed terminal snapshot updates the terminal slot. It never starts
+      // another turn (the next run.started/delta owns advancing the queue).
+      const old = current()
+      const wasTerminal = state.terminal
+      state.terminal = false
+      const failed =
+        ['run.failed', 'error'].includes(type) || p.error || ['failed', 'error'].includes(p.status)
+      const interrupted = ['interrupted', 'cancelled', 'canceled'].includes(p.status)
+      const output = p.output ?? p.text ?? p.content ?? p.message?.content
+      if (old || output || p.attachments)
+        saveAssistant({
+          content: output === '' ? (old?.content ?? '') : (output ?? old?.content ?? ''),
+          status: failed ? 'failed' : interrupted ? 'interrupted' : 'complete',
+          segment_kind: 'answer',
+          final_result: !failed && !interrupted,
+          ...(failed ? { error: p.error ?? p.message ?? '运行失败' } : {}),
+        })
+      state.error = failed ? String(p.error ?? p.message ?? '运行失败') : null
+      for (const m of this.all(...scope))
+        if (m.turn_id === state.turn) {
+          const calls = (m.tool_calls as Data[] | undefined)?.map((t) =>
+            ['running', 'pending'].includes(t.status) ? { ...t, status: 'interrupted' } : t,
+          )
+          if (m.status === 'streaming' || calls)
+            this.put(scope, {
+              ...m,
+              status: m.status === 'streaming' ? 'complete' : m.status,
+              ...(calls ? { tool_calls: calls } : {}),
+            })
+        }
+      state.terminal = true
+      state.preview = false
+      state.queued = state.queue.length > 0 || Number(p.queue_remaining ?? 0) > 0
+      state.running = state.queued || Number(p.background_pending ?? 0) > 0
+      state.resyncing = false
+      state.pendingApproval = null
+      state.pendingClarification = null
+      state.liveStatus = null
+      if (wasTerminal && state.queue.length === 0) state.running = false
+    } else if (type === 'route.resumed') {
+      const inflight = p.inflight ?? {},
+        running = p.running === true || p.info?.running === true || inflight.streaming === true
+      if (running) {
+        const hadCurrent = !!current()
+        begin()
+        if (typeof inflight.assistant === 'string' && (!hadCurrent || state.resyncing))
+          saveAssistant({ content: inflight.assistant, status: 'streaming' })
+        else assistant()
+      } else if (p.running === false) {
+        const old = current()
+        if (old && typeof inflight.assistant === 'string' && inflight.assistant)
+          this.put(scope, {
+            ...old,
+            content: inflight.assistant,
+            status: 'complete',
+            final_result: true,
+            segment_kind: 'answer',
+          })
+        state.running = false
+        state.terminal = true
+        state.resyncing = false
+        state.queued = Boolean(p.queued?.user) || Number(p.queue_length ?? p.info?.queue_length ?? 0) > 0
+        if (!state.queued) state.queue = []
+        for (const m of this.all(...scope))
+          if (m.status === 'streaming') this.put(scope, { ...m, status: 'complete' })
+      }
+      state.pendingApproval = p.pending_approval ?? inflight.pending_approval ?? null
+      state.pendingClarification = p.pending_clarify ?? inflight.pending_clarify ?? null
+    } else if (type === 'attachment.staged') {
+      const attachment = p.attachment ?? p.file ?? p
+      if (attachment.path || attachment.url)
+        state.stagedAttachments = [...(state.stagedAttachments ?? []), attachment]
+    } else if (type === 'gateway.reset') {
+      // Without a replay barrier, a resume body can overlap deferred deltas.
+      // Accept full snapshots until the terminal boundary, never append bytes
+      // whose position cannot be established. The idle history job fills gaps.
+      state.resyncing = true
+      state.liveStatus = '正在恢复回复'
+    } else if (['approval.request', 'approval.requested'].includes(type)) {
+      state.pendingApproval = p
+      state.running = true
+    } else if (type === 'approval.resolved') state.pendingApproval = null
+    else if (['clarify.request', 'clarify.requested'].includes(type)) {
+      state.pendingClarification = p
+      state.running = true
+    } else if (['clarify.resolved', 'clarify.expire'].includes(type)) state.pendingClarification = null
+    else if (type === 'status.update') {
+      state.liveStatus = text(p)
+      if (p.kind === 'warn') {
+        const source = `status:${state.turn ?? 'session'}:warning`
+        this.put(scope, {
+          id: this.alias(...scope, `source:${source}`) ?? source,
+          role: 'system',
+          turn_id: state.turn,
+          segment_kind: 'system',
+          content: text(p),
+          status: 'complete',
+          display_kind: 'live_warning',
+          final_result: false,
+        })
+      }
+    } else if (
+      [
+        'compression.started',
+        'compression.completed',
+        'session.command',
+        'session.workspace.updated',
+      ].includes(type)
+    ) {
+      const source = `system:${state.turn ?? 'session'}:${type.startsWith('compression.') ? 'compression' : type}`
+      const content =
+        type === 'compression.started'
+          ? '正在压缩上下文…'
+          : type === 'compression.completed'
+            ? '上下文压缩完成,继续回复'
+            : text(p)
+      if (content)
+        this.put(scope, {
+          id: this.alias(...scope, `source:${source}`) ?? source,
+          role: 'system',
+          turn_id: state.turn,
+          segment_kind: 'system',
+          content,
+          status: type.endsWith('started') ? 'streaming' : 'complete',
+          display_kind: type.startsWith('compression.') ? 'live_compression' : 'live_status',
+          final_result: false,
+        })
+    }
+    if (type === 'session.info') state.liveStatus = state.liveStatus ?? null
+    this.db
+      .prepare('UPDATE chat_transcript_heads SET data=? WHERE owner=? AND profile=? AND session_id=?')
+      .run(JSON.stringify(state), ...scope)
+    if (before !== JSON.stringify(state) || ['session.info', 'history.synced'].includes(type))
+      this.event(...scope, 'session.changed', {
+        eventType: type,
+        payload: type === 'session.info' ? p : {},
+        ...controlState(state),
+      })
+  }
+  migrate(owner: string, profile: string, oldID: string, newID: string) {
+    this.event(owner, profile, oldID, 'session.migrated', { sessionId: newID })
+    for (const table of [
+      'chat_transcript_messages',
+      'chat_transcript_aliases',
+      'chat_transcript_scopes',
+      'chat_transcript_execution',
+      'chat_transcript_heads',
+      'chat_transcript_reads',
+      'chat_transcript_source_cursors',
+      'chat_transcript_repairs',
+      'chat_transcript_archives',
+    ])
+      this.db
+        .prepare(`UPDATE ${table} SET session_id=? WHERE owner=? AND profile=? AND session_id=?`)
+        .run(newID, owner, profile, oldID)
+  }
+  remove(owner: string, profile: string, sessionId: string) {
+    this.event(owner, profile, sessionId, 'session.deleted', { sessionId })
+    for (const table of [
+      'chat_transcript_messages',
+      'chat_transcript_aliases',
+      'chat_transcript_scopes',
+      'chat_transcript_execution',
+      'chat_transcript_heads',
+      'chat_transcript_reads',
+      'chat_transcript_source_cursors',
+      'chat_transcript_repairs',
+      'chat_transcript_archives',
+    ])
+      this.db
+        .prepare(`DELETE FROM ${table} WHERE owner=? AND profile=? AND session_id=?`)
+        .run(owner, profile, sessionId)
+  }
+  cursor(owner: string, profile: string, sessionId: string): number {
+    return Number(
+      this.db
+        .prepare(
+          'SELECT COALESCE(MAX(cursor),0) cursor FROM chat_transcript_events WHERE owner=? AND profile=? AND session_id=?',
+        )
+        .get(owner, profile, sessionId)!.cursor,
+    )
+  }
+  events(owner: string, profile: string, sessionId: string, after: number, limit = 250): TranscriptEvent[] {
+    return (
+      this.db
+        .prepare(
+          'SELECT cursor,type,data FROM chat_transcript_events WHERE owner=? AND profile=? AND session_id=? AND cursor>? ORDER BY cursor LIMIT ?',
+        )
+        .all(owner, profile, sessionId, after, limit) as {
+        cursor: number
+        type: TranscriptEvent['type']
+        data: string
+      }[]
+    ).map((row) => ({ ...row, profile, sessionId, ...JSON.parse(row.data) }))
+  }
+  snapshot(
+    owner: string,
+    profile: string,
+    sessionId: string,
+    session: Record<string, unknown>,
+    state: string,
+    before = Number.MAX_SAFE_INTEGER,
+    limit = 150,
+  ): TranscriptSnapshot {
+    const run = this.head(owner, profile, sessionId)
+    const coverage = this.db
+      .prepare(
+        'SELECT complete,message_total FROM chat_sessions WHERE owner=? AND profile=? AND session_id=?',
+      )
+      .get(owner, profile, sessionId)
+    const incomplete = coverage?.complete === 0
+    const rows = this.db
+      .prepare(
+        'SELECT data FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=0 AND seq<? ORDER BY seq DESC,id DESC LIMIT ?',
+      )
+      .all(owner, profile, sessionId, before, limit + 1) as { data: string }[]
+    return {
+      protocol: CHAT_TRANSCRIPT_FEATURE,
+      epoch: this.epochFor(owner, profile, sessionId),
+      cursor: this.cursor(owner, profile, sessionId),
+      profile,
+      sessionId,
+      running: run.running,
+      queued: run.queued,
+      pendingApproval: run.pendingApproval,
+      pendingClarification: run.pendingClarification,
+      liveStatus: run.liveStatus,
+      error: run.error,
+      messages: rows
+        .slice(0, limit)
+        .reverse()
+        .map((row) => JSON.parse(row.data)),
+      session,
+      state,
+      deletedIds: (
+        this.db
+          .prepare(
+            'SELECT id FROM chat_transcript_messages WHERE owner=? AND profile=? AND session_id=? AND deleted=1',
+          )
+          .all(owner, profile, sessionId) as { id: string }[]
+      ).map((row) => row.id),
+      hasOlder: rows.length > limit || (incomplete && before > 1),
+      total: Math.max(
+        this.total(owner, profile, sessionId),
+        incomplete ? Number(coverage?.message_total ?? 0) : 0,
+      ),
+    }
   }
 }

+ 6 - 4
src/server/grokCloud.ts

@@ -187,13 +187,15 @@ export class GrokCloud {
       if(!token)throw new HttpError(400,'请先通过浏览器完成 Grok Bot 授权。','grok_login_missing');ctx.body=await this.configure(owner,token,body.version,refreshToken)
     })
     router.put('/api/app/agents/:id/computer-selection',async ctx=>{
-      const owner=this.auth.require(ctx).id,agent=this.agent(owner,ctx.params.id),body=parse(z.object({computer:z.enum(['auto','cloud','vm','local','browser','off']),allowHostEnvironment:z.boolean().optional()}).strict(),(ctx.request as any).body)
+      const owner=this.auth.require(ctx).id,agent=this.agent(owner,ctx.params.id),body=parse(z.object({computer:z.enum(['auto','cloud','vm','local','browser','off']),allowHostEnvironment:z.boolean().optional(),vmExecution:z.enum(['worker','profile']).optional()}).strict(),(ctx.request as any).body)
       this.beforeSelection?.(owner,agent.id);this.shared.assertLocalVmIdle(owner,[agent.id]);if(this.current(owner))throw new HttpError(409,'请先交还云端电脑','computer_busy')
-      const allowHostEnvironment=['vm','cloud'].includes(body.computer)&&(body.allowHostEnvironment??agent.allowHostEnvironment??false)
-      if(body.computer==='vm'&&allowHostEnvironment)this.nodes.targetForAgent(owner,{...agent,execution:'computer',computer:'vm',allowHostEnvironment:true})
+      if(body.vmExecution==='profile'&&body.allowHostEnvironment===false)throw new HttpError(400,'本机协作模式需要本机环境,请选择虚拟机模式','computer_profile_host_required')
+      const vmExecution=body.computer==='vm'?(body.vmExecution??(body.allowHostEnvironment===false?'worker':agent.vmExecution)??'worker'):'worker'
+      const allowHostEnvironment=(body.computer==='vm'&&vmExecution==='profile')||(['vm','cloud'].includes(body.computer)&&(body.allowHostEnvironment??(body.vmExecution==='worker'?false:agent.allowHostEnvironment)??false))
+      if(body.computer==='vm'&&allowHostEnvironment)this.nodes.targetForAgent(owner,{...agent,execution:'computer',computer:'vm',allowHostEnvironment:true,vmExecution})
       const enteringCloud=body.computer==='cloud'&&agent.computer!=='cloud'
       if(enteringCloud)await this.requireAvailable(owner,agent,this.nodes.target(owner,agent.nodeId))
-      this.store.atomic(()=>{const execution=body.computer==='vm'?'computer':body.computer==='auto'?(agent.execution??'profile'):'profile';if(execution!=='computer'&&agent.computerEnvironmentId)this.shared.detachLocalVm(owner,agent);this.store.updateAgent(owner,agent.id,{computer:body.computer,execution,allowHostEnvironment});const current=this.store.require<WorkspaceAgent>(owner,'agent',agent.id);this.store.prepareAgent?.(owner,current);this.store.put(owner,'agent',agent.id,current)})
+      this.store.atomic(()=>{const execution=body.computer==='vm'?'computer':body.computer==='auto'?(agent.execution??'profile'):'profile';if(execution!=='computer'&&agent.computerEnvironmentId)this.shared.detachLocalVm(owner,agent);this.store.updateAgent(owner,agent.id,{computer:body.computer,execution,allowHostEnvironment,vmExecution});const current=this.store.require<WorkspaceAgent>(owner,'agent',agent.id);this.store.prepareAgent?.(owner,current);this.store.put(owner,'agent',agent.id,current)})
       if(enteringCloud)await this.connect(owner)
       ctx.body={agent:this.store.agentSummary(this.store.require<WorkspaceAgent>(owner,'agent',agent.id))}
     })

+ 4 - 1
src/server/realtimeApi.ts

@@ -13,6 +13,7 @@ import { HttpError } from './errors.js'
 import { configuredWorkingDirectory } from './sessionWorkingDirectory.js'
 import { canonicalEpoch, groupCursor } from './realtimeProtocol.js'
 import { CHAT_MAX_PAYLOAD } from './realtimeProtocol.js'
+import { CHAT_TRANSCRIPT_FEATURE } from '../shared/chatTranscript.js'
 import { ChatPushRelayObserver, type ChatNotificationResolver, type PushEventCoordinator, type ChatPushTransportFactory } from './pushEvents.js'
 
 export class RealtimeAPI {
@@ -170,7 +171,7 @@ export class RealtimeAPI {
       const path = match![2]!
       if (ctx.method === 'GET' && path === '/capabilities') {
         ctx.body = { protocolVersion: 1, channels: ['chat'], brokerEpoch: this.broker.epoch,
-          features: this.transcriptsAvailable && !device && !ctx.state.hermesBotNative && !ctx.state.workspaceAgentExport ? ['ordinary-chat-transcript-v1'] : [],
+          features: this.transcriptsAvailable && !device && !ctx.state.hermesBotNative && !ctx.state.workspaceAgentExport ? [CHAT_TRANSCRIPT_FEATURE] : [],
           ...(device ? {} : { csrfToken: this.csrf.issue(ctx) }) }
         return
       }
@@ -179,6 +180,8 @@ export class RealtimeAPI {
         const body = await this.body(ctx)
         if (ctx.state.workspaceAgentExport && body.channel !== 'chat') throw new HttpError(403,'机器人仅支持聊天通道','invalid_channel')
         if (body.channel !== 'chat' && body.channel !== 'groups') throw new HttpError(400, 'Invalid channel', 'invalid_channel')
+        if(this.transcriptsAvailable&&body.channel==='chat'&&!device&&!principal.nativeBot&&!ctx.state.workspaceAgentExport&&body.chatProtocol!==CHAT_TRANSCRIPT_FEATURE)
+          throw new HttpError(426,'普通聊天协议已升级,请更新客户端后继续','ordinary_chat_upgrade_required')
         const c = await this.broker.create(principal, body.channel, body.channel === 'groups'
           ? { epoch: canonicalEpoch(body.epoch), cursor: groupCursor(body.cursor) } : undefined)
         ctx.status = 201; ctx.body = { id: c.id, brokerEpoch: this.broker.epoch }; return

+ 18 - 7
src/server/realtimeBroker.ts

@@ -50,7 +50,8 @@ export class RealtimeBroker {
   onNativeEvent: (owner: string, profile: string, storedId: string, frame: Frame) => void = () => {}
   onNativeGlobalEvent: (owner: string, type: string, upstreamInvalidation?: boolean) => void = () => {}
   onNativeCommand: (owner: string, profile: string, storedId: string, method: string, params: Frame) => void = () => {}
-  onNativeRoute: (owner: string, profile: string, storedId: string, runtimeId: string, running?: boolean) => void = () => {}
+  onNativeRoute: (owner: string, profile: string, storedId: string, runtimeId: string, running?: boolean, snapshot?: Frame) => void = () => {}
+  nativeSourceCursor: (owner:string,profile:string,storedId:string,runtimeId:string,epoch:string)=>number = () => 0
   readonly epoch = randomUUID()
   readonly channels = new Map<string, RealtimeChannel>()
   private upstreams = new Map<string, Upstream>()
@@ -283,7 +284,10 @@ export class RealtimeBroker {
         r.cwd = typeof info.cwd === 'string' ? info.cwd : undefined
         u.routes.set(key, r); u.byRuntime.set(runtime, r); c.routes.add(key)
         r.observers.set(c.principal.key, c.principal)
-        if (nativeOwner) this.onNativeRoute(nativeOwner, profile, stored, runtime, r.active)
+        if (nativeOwner) {
+          r.seq=Math.max(r.seq,this.nativeSourceCursor(nativeOwner,profile,stored,runtime,u.epoch??''))
+          this.onNativeRoute(nativeOwner, profile, stored, runtime, r.active, result)
+        }
         if (nativeOwner && (method === 'session.create' || method === 'session.branch')) {
           this.onNativeCommand(nativeOwner, profile, stored, method, {...p,_delivery_id:deliveryID})
         }
@@ -433,13 +437,13 @@ export class RealtimeBroker {
       if (p.payload?.request_id) this.interactions.set(`${u.principal.upstreamKey}:${p.payload.request_id}`, sid)
       while (this.interactions.size > 10_000) this.interactions.delete(this.interactions.keys().next().value!)
     }
-    const deliveryID = Number.isSafeInteger(p.seq) ? `${this.epoch}:${sid}:${p.seq}` : randomUUID()
+    const deliveryID = Number.isSafeInteger(p.seq) ? `${u.epoch??this.epoch}:${sid}:${p.seq}` : randomUUID()
     const persistedOwners = new Set<string>()
     if (r) for (const principal of r.observers.values()) {
       if (principal.valid()) {
         principal.observeEvent?.(JSON.stringify(f))
         const owner = this.nativeOwner(principal)
-        if (owner && !persistedOwners.has(owner)) { persistedOwners.add(owner); const projected={...p,delivery_id:deliveryID,epoch:this.epoch}; this.onNativeEvent(owner, r.profile, r.stored, projected); p.payload=projected.payload }
+        if (owner && !persistedOwners.has(owner)) { persistedOwners.add(owner); this.onNativeEvent(owner, r.profile, r.stored, {...p,delivery_id:deliveryID,epoch:u.epoch??this.epoch}) }
       }
     }
     if (!r && p.type === 'sessions.changed') {
@@ -493,13 +497,20 @@ export class RealtimeBroker {
         r.workingDirectory = undefined
         r.cwd = typeof resumed.result?.info?.cwd === 'string' ? resumed.result.info.cwd : undefined
         if (typeof resumed.result?.running === 'boolean') r.active = resumed.result.running
+        const restore=(snapshot:boolean)=>{
+          for(const principal of r.observers.values()){
+            const owner=this.nativeOwner(principal)
+            if(owner&&principal.valid()&&resumed.result)this.onNativeRoute(owner,r.profile,r.stored,String(resumed.result.session_id??r.runtime),r.active,
+              snapshot?resumed.result:{...resumed.result,inflight:undefined})
+          }
+        }
         if (!resumed.result || resumed.result.session_id !== r.runtime || changed) {
           if (resumed.result?.session_id) { u.byRuntime.delete(r.runtime); r.runtime = resumed.result.session_id; u.byRuntime.set(r.runtime, r) }
-          r.seq = 0; this.reset(u, 'upstream_reset'); continue
+          r.seq = 0; this.reset(u, 'upstream_reset'); restore(true); continue
         }
         const replay = await this.rpc(u, 'session.events.since', { session_id: r.runtime, last_seen: lastSeen })
-        if (replay.error || replay.result?.truncated || replay.result?.epoch !== u.epoch) this.reset(u, 'upstream_replay_unavailable')
-        else for (const p of replay.result?.events ?? []) this.event(u, { jsonrpc: '2.0', method: 'event', params: p }, true)
+        if (replay.error || replay.result?.truncated || replay.result?.epoch !== u.epoch) {this.reset(u, 'upstream_replay_unavailable');restore(true)}
+        else {for (const p of replay.result?.events ?? []) this.event(u, { jsonrpc: '2.0', method: 'event', params: p }, true);restore(false)}
       }
     } catch { this.reset(u, 'upstream_recovery_failed') }
     finally {

+ 6 - 1
src/server/runnerHub.ts

@@ -117,6 +117,7 @@ export class RunnerHub {
       if(!this.auth.canUseSource(owner,sourceNodeId,profile)||!record.allowedProfiles.includes(profile))throw new HttpError(403,'执行节点未授权这个基础 Profile','runner_profile_forbidden')
     }
     const requireComputer=()=>{
+      if(computer?.profileSession&&!this.online.get(record.id)?.features.includes('profile-computer-v1'))throw new HttpError(409,'执行节点尚不支持本机协作模式,请更新配套 Runner','computer_profile_unavailable')
       if(computer?.hostAccess&&!this.online.get(record.id)?.features.includes('host-computer-tools-v1'))throw new HttpError(409,'执行节点版本不支持同时使用本机和虚拟机,请更新 Runner','computer_host_tools_unavailable')
       if(computer&&this.composeDesktops.desktops.length){
         if(!this.online.get(record.id)?.features.includes('compose-desktops-v1'))throw new HttpError(409,'当前部署需要 Compose 桌面执行节点','compose_runner_required')
@@ -151,6 +152,10 @@ export class RunnerHub {
           const valid=()=>{
             try{
               scope?.authorize()
+              if(computer&&!scope?.cleanupOnly){
+                const agent=this.store.get<import('../shared/workspace.js').WorkspaceAgent>(owner,'agent',computer.agentId)
+                if(!agent||(agent.vmExecution==='profile')!==(computer.profileSession===true))return false
+              }
               if(computer?.hostAccess){
                 const agent=this.store.get<import('../shared/workspace.js').WorkspaceAgent>(owner,'agent',computer.agentId)
                 if(!agent||agent.archived||agent.temporaryGoalId||agent.allowHostEnvironment!==true||(agent.computer!=='vm'&&agent.computer!==undefined)||agent.execution!=='computer')return false
@@ -241,7 +246,7 @@ export class RunnerHub {
         retired.add(previous.instance);this.retired.set(record.id,retired);this.disconnect(record.id);previous=undefined
       }
       if(match[2]!=='poll'&&ctx.get('x-runner-epoch')!==previous?.epoch)throw new HttpError(409,'执行连接代次已改变','runner_epoch_changed')
-      const state=this.online.get(record.id)??{instance,seen:Date.now(),features:[],epoch:`${this.epoch}:${randomUUID()}`};state.seen=Date.now();if(ctx.get('x-runner-features'))state.features=ctx.get('x-runner-features').split(',').filter(value=>['host-computer-tools-v1','idle-stop-policy-v1','computer-worker-v1','artifact-chunks-v1','helper-retirement-v1','computer-control-v1','shared-computer-v1','local-vm-v1','image-options-v1','image-ready-v1','compose-desktops-v1'].includes(value));this.online.set(record.id,state)
+      const state=this.online.get(record.id)??{instance,seen:Date.now(),features:[],epoch:`${this.epoch}:${randomUUID()}`};state.seen=Date.now();if(ctx.get('x-runner-features'))state.features=ctx.get('x-runner-features').split(',').filter(value=>['profile-computer-v1','host-computer-tools-v1','idle-stop-policy-v1','computer-worker-v1','artifact-chunks-v1','helper-retirement-v1','computer-control-v1','shared-computer-v1','local-vm-v1','image-options-v1','image-ready-v1','compose-desktops-v1'].includes(value));this.online.set(record.id,state)
       ctx.set('Cache-Control','no-store')
       if(match[2]==='poll') {
         if(ctx.method!=='GET')throw new HttpError(405,'仅允许 GET','method_not_allowed')

+ 2 - 2
src/server/workspaceGateway.ts

@@ -107,10 +107,10 @@ export class WorkspaceNodes {
     }
     return target
   }
-  targetForAgent(owner: string, agent: { id?:string;nodeId: string; remoteAgentId?: string;execution?:string;computer?:WorkspaceAgent['computer'];allowHostEnvironment?:boolean;temporaryGoalId?:string;helperRunnerId?:string;computerEnvironmentId?:string }): GatewayTarget {
+  targetForAgent(owner: string, agent: { id?:string;nodeId: string; remoteAgentId?: string;execution?:string;computer?:WorkspaceAgent['computer'];allowHostEnvironment?:boolean;vmExecution?:WorkspaceAgent['vmExecution'];temporaryGoalId?:string;helperRunnerId?:string;computerEnvironmentId?:string }): GatewayTarget {
     if(agent.execution==='computer'){
       if(!agent.id||agent.remoteAgentId)throw new HttpError(409,'隔离电脑需要当前服务器管理的机器人','computer_agent_required')
-      const target=this.runnerTarget?.(owner,agent.nodeId,{environmentId:agent.computerEnvironmentId??agent.id,agentId:agent.id,ownerKey:createHash('sha256').update(owner).digest('hex'),...(agent.allowHostEnvironment===true&&(agent.computer==='vm'||!agent.computer)&&!agent.temporaryGoalId?{hostAccess:true}:{})})
+      const target=this.runnerTarget?.(owner,agent.nodeId,{environmentId:agent.computerEnvironmentId??agent.id,agentId:agent.id,ownerKey:createHash('sha256').update(owner).digest('hex'),...(agent.vmExecution==='profile'&&!agent.temporaryGoalId?{profileSession:true}:{}),...(agent.allowHostEnvironment===true&&(agent.computer==='vm'||!agent.computer)&&!agent.temporaryGoalId?{hostAccess:true}:{})})
       if(agent.computerEnvironmentId&&this.store.require<import('./sharedComputers.js').SharedComputer>(owner,'shared-computer',agent.computerEnvironmentId).runnerId!==target?.runner?.id)throw new HttpError(409,'共享电脑的原执行节点已变化,请先恢复原节点','shared_runner_changed')
       if(agent.helperRunnerId&&target?.runner?.id!==agent.helperRunnerId)throw new HttpError(409,'临时助手的原执行节点已变化,请创建新助手','helper_runner_changed')
       if(!target)throw new HttpError(409,'隔离电脑需要连接执行节点','computer_runner_required')

+ 4 - 2
src/server/workspaceRuntime.ts

@@ -29,6 +29,7 @@ type Run = WorkspaceRun
 export interface WorkspaceBinding {
   runnerId?: string
   execution?:string
+  vmExecution?:Agent["vmExecution"]
   computerEnvironmentId?:string
   remoteAgentId?: string
   id: string
@@ -212,11 +213,11 @@ export class WorkspaceRuntime extends WorkspaceScheduler {
     },authorize:()=>{
       this.requireAuthorization(owner,run.runId);this.nodes.requireSource(owner,agent)
       const current=this.getWork(owner,run.id),latest=this.store.require<Agent>(owner,'agent',agent.id),conversation=this.store.require<Conversation>(owner,'conversation',c.id)
-      if(this.closing||conversation.archived||!this.store.taskMemberIds(owner,conversation,run.conversationTaskId).includes(agent.id)||this.store.require<Run>(owner,'run',run.runId).stopRequested||current.cancelRequested||['interrupted','complete','failed'].includes(current.status)||latest.archived||latest.computerEnvironmentId!==agent.computerEnvironmentId||(latest.allowHostEnvironment===true)!==(agent.allowHostEnvironment===true)||(latest.execution??'profile')!==(agent.execution??'profile')||latest.teamAuthorizationVersion!==agent.teamAuthorizationVersion)throw new HttpError(403,'本轮机器人或任务授权已结束','run_authorization_revoked')
+      if(this.closing||conversation.archived||!this.store.taskMemberIds(owner,conversation,run.conversationTaskId).includes(agent.id)||this.store.require<Run>(owner,'run',run.runId).stopRequested||current.cancelRequested||['interrupted','complete','failed'].includes(current.status)||latest.archived||latest.computerEnvironmentId!==agent.computerEnvironmentId||(latest.vmExecution??'worker')!==(agent.vmExecution??'worker')||(latest.allowHostEnvironment===true)!==(agent.allowHostEnvironment===true)||(latest.execution??'profile')!==(agent.execution??'profile')||latest.teamAuthorizationVersion!==agent.teamAuthorizationVersion)throw new HttpError(403,'本轮机器人或任务授权已结束','run_authorization_revoked')
     }})
     gateway.onTrace=entry=>this.inspector?.record(owner,c.id,{...entry,agentId:agent.id,runId:run.runId,taskId:run.conversationTaskId})
     let binding = this.store.get<WorkspaceBinding>(owner, 'binding', key)
-    const movedRunner=!!this.store.get(owner,'binding-reset',key)||!!binding&&(binding.computerEnvironmentId!==agent.computerEnvironmentId||binding.runnerId!==target.runner?.id||(binding.execution??'profile')!==(agent.execution??'profile'))
+    const movedRunner=!!this.store.get(owner,'binding-reset',key)||!!binding&&((binding.vmExecution??'worker')!==(agent.vmExecution??'worker')||binding.computerEnvironmentId!==agent.computerEnvironmentId||binding.runnerId!==target.runner?.id||(binding.execution??'profile')!==(agent.execution??'profile'))
     if(movedRunner) {
       if(recovering)throw new HttpError(409,'执行节点已变化,不能在另一节点重放原执行','runner_target_changed')
       binding=undefined
@@ -500,6 +501,7 @@ export class WorkspaceRuntime extends WorkspaceScheduler {
       binding = {
         runnerId: target.runner?.id,
         execution:agent.execution,
+        vmExecution:agent.vmExecution,
         computerEnvironmentId:agent.computerEnvironmentId,
         id: key,
         nodeId: agent.nodeId,

+ 12 - 1
src/server/workspaceStore.ts

@@ -43,6 +43,7 @@ export const agentInput = z
     execution:z.enum(['profile','computer']).default('profile'),
     computer:z.enum(['auto','cloud','vm','local','browser','off']).optional(),
     allowHostEnvironment:z.boolean().default(false),
+    vmExecution:z.enum(['worker','profile']).optional(),
     browserProfile:z.enum(['persistent','temporary']).optional(),
     canManageTeam: z.boolean().default(false),
     nodeId: z.string().default('local'),
@@ -57,6 +58,7 @@ export const agentPatch = z
     execution:z.enum(['profile','computer']).optional(),
     computer:z.enum(['auto','cloud','vm','local','browser','off']).optional(),
     allowHostEnvironment:z.boolean().optional(),
+    vmExecution:z.enum(['worker','profile']).optional(),
     browserProfile:z.enum(['persistent','temporary']).optional(),
     nodeId:z.string().min(1).max(256).optional(),
     profile:z.string().min(1).max(256).optional(),
@@ -373,6 +375,8 @@ export class WorkspaceStore {
   createAgent(owner: string, input: unknown, origin?: { createdByAgentId: string; createdFromRunId: string;temporaryGoalId?:string;helperActivation?:number;helperRunnerId?:string }): Agent {
     const body = parse(agentInput, input)
     if(!supportsHostEnvironment(body)||origin)body.allowHostEnvironment=false
+    if(body.computer!=='vm'||origin)body.vmExecution='worker'
+    if(body.vmExecution==='profile')body.allowHostEnvironment=true
     if (origin) this.require<Agent>(owner, 'agent', origin.createdByAgentId)
     return this.atomic(() => {
       if (
@@ -429,10 +433,17 @@ export class WorkspaceStore {
     if (patch.avatar !== undefined) patch.avatar = normalizeAvatar(patch.avatar)
     return this.atomic(() => {
       const agent = this.require<Agent>(owner, 'agent', id)
+      if(patch.vmExecution==='profile'&&patch.allowHostEnvironment===false)throw new HttpError(400,'本机协作模式需要本机环境,请选择虚拟机模式','computer_profile_host_required')
+      if(agent.vmExecution==='profile'){
+        if(patch.allowHostEnvironment===false&&patch.vmExecution===undefined)patch.vmExecution='worker'
+        if(patch.vmExecution==='worker'&&patch.allowHostEnvironment===undefined)patch.allowHostEnvironment=false
+      }
+      if((patch.computer??agent.computer)!=='vm'&&(patch.vmExecution!==undefined||agent.vmExecution==='profile'))patch.vmExecution='worker'
+      if((patch.vmExecution??agent.vmExecution)==='profile'&&(patch.computer??agent.computer)==='vm')patch.allowHostEnvironment=true
       if(!supportsHostEnvironment({...agent,...patch})&&(agent.allowHostEnvironment===true||patch.allowHostEnvironment!==undefined))patch.allowHostEnvironment=false
       const sourceChanged=(patch.nodeId!==undefined&&patch.nodeId!==agent.nodeId)||(patch.profile!==undefined&&patch.profile!==agent.profile)
       const hostPermissionChanged=patch.allowHostEnvironment!==undefined&&patch.allowHostEnvironment!==(agent.allowHostEnvironment===true)
-      const destinationChanged=hostPermissionChanged||(patch.computer!==undefined&&patch.computer!==agent.computer)||(patch.browserProfile!==undefined&&patch.browserProfile!==(agent.browserProfile??'persistent'))
+      const destinationChanged=hostPermissionChanged||(patch.vmExecution!==undefined&&patch.vmExecution!==(agent.vmExecution??'worker'))||(patch.computer!==undefined&&patch.computer!==agent.computer)||(patch.browserProfile!==undefined&&patch.browserProfile!==(agent.browserProfile??'persistent'))
       if(sourceChanged||destinationChanged){
         if(this.list<{agentId:string;status:string}>(owner,'turn').some(work=>work.agentId===id&&['queued','running','waiting','uncertain','cancelling'].includes(work.status)))throw new HttpError(409,'请先停止当前任务,再修改机器人来源或电脑','agent_execution_busy')
         if(this.list<{owner:string;agentId:string;environmentId?:string;expiresAt:number}>('_system','computer-control').some(grant=>grant.owner===owner&&grant.expiresAt>Date.now()&&(grant.agentId===id||grant.environmentId===(agent.computerEnvironmentId??id))))throw new HttpError(409,'请先交还电脑控制权','agent_execution_busy')

+ 1 - 1
src/server/workspaceTeamTools.ts

@@ -11,7 +11,7 @@ import { assignmentInput, assignmentReview, assignmentUpdate, assignmentCancel,
 
 const uuid = z.string().uuid()
 const empty = z.object({}).strict()
-const createAgent = agentInput.omit({ canManageTeam: true, allowHostEnvironment:true }).extend({ requestId: uuid,execution:z.enum(['profile','computer']).optional() }).strict()
+const createAgent = agentInput.omit({ canManageTeam: true, allowHostEnvironment:true, vmExecution:true }).extend({ requestId: uuid,execution:z.enum(['profile','computer']).optional() }).strict()
 const createHelper=agentInput.pick({name:true,instructions:true}).extend({requestId:uuid,goalId:uuid,profile:z.string().min(1).max(256).optional(),title:z.string().trim().min(1).max(100),brief:z.string().trim().min(1).max(16000),acceptanceCriteria:z.array(z.string().trim().min(1).max(1000)).max(12).default([]),dependsOn:z.array(uuid).max(12).default([])}).strict()
 const createTeam = z.object({
   requestId: uuid,

+ 73 - 20
src/shared/chatTranscript.ts

@@ -1,11 +1,13 @@
 /** Ordinary-chat display protocol. Upstream identities remain server metadata. */
-export const CHAT_TRANSCRIPT_FEATURE = 'ordinary-chat-transcript-v1'
+export const CHAT_TRANSCRIPT_FEATURE = 'ordinary-chat-transcript-v2'
 export interface TranscriptMessage {
   id: string
   seq: number
   revision: number
   source_message_id: string
   client_message_id?: string
+  turn_id?: string
+  segment_kind?: 'input' | 'commentary' | 'answer' | 'tool' | 'system'
   role: string
   content: unknown
   reasoning?: string
@@ -13,47 +15,98 @@ export interface TranscriptMessage {
   [key: string]: unknown
 }
 export interface TranscriptPatch {
-  id: string; seq: number; baseRevision: number; revision: number
-  contentAppend: string; reasoningAppend: string
+  id: string
+  seq: number
+  baseRevision: number
+  revision: number
+  contentAppend: string
+  reasoningAppend: string
 }
 export interface TranscriptEvent {
-  cursor: number; profile: string; sessionId: string
-  type: 'message.upsert' | 'message.patch' | 'message.deleted' | 'session.changed' | 'session.deleted' | 'session.migrated'
+  cursor: number
+  profile: string
+  sessionId: string
+  epoch?: string
+  previousCursor?: number
+  total?: number
+  type:
+    | 'message.upsert'
+    | 'message.patch'
+    | 'message.deleted'
+    | 'session.changed'
+    | 'session.deleted'
+    | 'session.migrated'
   data: unknown
 }
 export interface TranscriptSnapshot {
-  protocol: typeof CHAT_TRANSCRIPT_FEATURE; epoch: string; cursor: number
-  profile: string; sessionId: string; messages: TranscriptMessage[]
-  session: Record<string, unknown>; hasOlder: boolean; total: number
+  protocol: typeof CHAT_TRANSCRIPT_FEATURE
+  epoch: string
+  cursor: number
+  profile: string
+  sessionId: string
+  messages: TranscriptMessage[]
+  session: Record<string, unknown>
+  hasOlder: boolean
+  total: number
   state: string
   deletedIds?: string[]
   running?: boolean
   queued?: boolean
+  pendingApproval?: Record<string, unknown> | null
+  pendingClarification?: Record<string, unknown> | null
+  liveStatus?: string | null
+  error?: string | null
 }
 export class TranscriptGap extends Error {
-  constructor() { super('普通聊天消息版本不连续,需要重新同步') }
+  constructor() {
+    super('普通聊天消息版本不连续,需要重新同步')
+  }
 }
-export function applyTranscriptEvent(messages: TranscriptMessage[], event: TranscriptEvent): TranscriptMessage[] {
+export function applyTranscriptEvent(
+  messages: TranscriptMessage[],
+  event: TranscriptEvent,
+): TranscriptMessage[] {
   const data = event.data as TranscriptMessage & TranscriptPatch
-  const index = messages.findIndex(message => message.id === data.id)
+  const index = messages.findIndex((message) => message.id === data.id)
   const old = messages[index]
   if (event.type === 'message.deleted') {
-    if(!Number.isSafeInteger(data.revision)||data.revision<1)throw new TranscriptGap()
-    return old&&old.revision>=data.revision?messages:messages.filter(message => message.id !== data.id)
+    if (!Number.isSafeInteger(data.revision) || data.revision < 1) throw new TranscriptGap()
+    return old && old.revision >= data.revision
+      ? messages
+      : messages.filter((message) => message.id !== data.id)
   }
   if (event.type === 'message.upsert') {
-    if (!data.id || !Number.isSafeInteger(data.seq) || !Number.isSafeInteger(data.revision) || data.revision < 1) throw new TranscriptGap()
+    if (
+      !data.id ||
+      !Number.isSafeInteger(data.seq) ||
+      !Number.isSafeInteger(data.revision) ||
+      data.revision < 1
+    )
+      throw new TranscriptGap()
     if (old && old.revision >= data.revision) return messages
-    return [...messages.filter(message => message.id !== data.id), data].sort((a,b) => a.seq-b.seq || a.id.localeCompare(b.id))
+    return [...messages.filter((message) => message.id !== data.id), data].sort(
+      (a, b) => a.seq - b.seq || a.id.localeCompare(b.id),
+    )
   }
   if (event.type === 'message.patch') {
     if (old && old.revision >= data.revision) return messages
-    if (!old || old.revision !== data.baseRevision || data.revision !== data.baseRevision+1
-      || old.seq !== data.seq || typeof old.content !== 'string'
-      || typeof data.contentAppend !== 'string' || typeof data.reasoningAppend !== 'string') throw new TranscriptGap()
+    if (
+      !old ||
+      old.revision !== data.baseRevision ||
+      data.revision !== data.baseRevision + 1 ||
+      old.seq !== data.seq ||
+      typeof old.content !== 'string' ||
+      typeof data.contentAppend !== 'string' ||
+      typeof data.reasoningAppend !== 'string'
+    )
+      throw new TranscriptGap()
     const next = [...messages]
-    next[index] = {...old, revision:data.revision, content:old.content+data.contentAppend,
-      reasoning:String(old.reasoning??'')+data.reasoningAppend}
+    next[index] = {
+      ...old,
+      revision: data.revision,
+      content: old.content + data.contentAppend,
+      reasoning: String(old.reasoning ?? '') + data.reasoningAppend,
+    }
     return next
   }
   return messages

+ 2 - 0
src/shared/workspace.ts

@@ -8,6 +8,8 @@ export interface WorkspaceAgent {
   execution?: 'profile' | 'computer'
   computer?: 'auto' | 'cloud' | 'vm' | 'local' | 'browser' | 'off'
   allowHostEnvironment?: boolean
+  /** Local VM execution backend; older records retain the isolated Worker. */
+  vmExecution?: 'worker' | 'profile'
   browserProfile?: 'persistent' | 'temporary'
   computerEnvironmentId?:string
   computerEnvironmentName?:string

+ 233 - 236
tests/client/chatCrossClientSync.test.ts

@@ -1,278 +1,275 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { createPinia, setActivePinia } from 'pinia'
-import type { RealtimeConnectionState, RpcEventFrame, SessionSummary } from '@shared/types'
-import { routeKey } from '@/utils/id'
-
-const realtime = vi.hoisted(() => ({
-  event: undefined as ((event: RpcEventFrame['params']) => void) | undefined,
-  state: undefined as ((state: RealtimeConnectionState) => void) | undefined,
+import type { TranscriptSnapshot } from '@shared/chatTranscript'
+import type { RpcEventFrame, RealtimeConnectionState } from '@shared/types'
+const wire = vi.hoisted(() => ({
+  event: undefined as ((e: RpcEventFrame['params']) => void) | undefined,
+  state: undefined as ((s: RealtimeConnectionState) => void) | undefined,
   request: vi.fn(),
+  clients: [] as any[],
+  owner: 0,
+  supported: true,
 }))
-const api = vi.hoisted(() => ({ getMessages: vi.fn() }))
+const api = vi.hoisted(() => ({ messages: vi.fn(), sessions: vi.fn() }))
 vi.mock('@/api/realtime', () => ({
   RpcError: class extends Error {},
   ChatRpcSocket: class {
-    onEvent(handler: typeof realtime.event) { realtime.event = handler }
-    onState(handler: typeof realtime.state) { realtime.state = handler }
-    async connect() { realtime.state?.('ready') }
+    get transcriptSupported() {
+      return wire.supported
+    }
+    onEvent(f: typeof wire.event) {
+      wire.event = f
+    }
+    onState(f: typeof wire.state) {
+      wire.state = f
+    }
+    async connect() {
+      wire.state?.('ready')
+    }
     close() {}
-    async request(...args: unknown[]) { return realtime.request(...args) }
+    async request(...args: unknown[]) {
+      return wire.request(...args)
+    }
+  },
+}))
+vi.mock('@/api/chatTranscript', () => ({
+  ChatTranscriptClient: class {
+    close = vi.fn()
+    loadOlder = vi.fn()
+    restore = vi.fn()
+    run = vi.fn()
+    constructor(
+      readonly profile: string,
+      readonly id: string,
+      readonly changed: (value: TranscriptSnapshot) => Promise<void>,
+      readonly failed: (error: Error) => void,
+    ) {
+      wire.clients.push(this)
+    }
   },
 }))
 vi.mock('@/api/sessions', () => ({
-  getMessages: api.getMessages, getSession: vi.fn(), getSessions: vi.fn(),
-  deleteSession: vi.fn(), getSessionUnread: vi.fn(), markSessionRead: vi.fn(), updateSession: vi.fn(),
+  getMessages: api.messages,
+  getSessions: api.sessions,
+  getSession: vi.fn(),
+  deleteSession: vi.fn(),
+  getSessionUnread: vi.fn(),
+  markSessionRead: vi.fn(),
+  updateSession: vi.fn(),
+  requestHistorySync: vi.fn(),
 }))
 vi.mock('@/api/profiles', () => ({ getModels: vi.fn() }))
 vi.mock('@/stores/auth', () => ({
   useAuthStore: () => ({
-    user: { id: 'viewer' }, activeProfile: { name: 'alpha' },
-    status: 'authenticated', isAuthenticated: true,
+    user: { id: `v2-viewer-${wire.owner}` },
+    activeProfile: { name: 'p' },
+    status: 'authenticated',
+    isAuthenticated: true,
   }),
 }))
-
 import { useChatStore } from '@/stores/chat'
-
-function session(id = 'stored-1'): SessionSummary {
-  return { id, profile: 'alpha', owned: true, source: 'ios', title: '跨端聊天',
-    messageCount: 0, toolCallCount: 0, startedAt: 1, updatedAt: 2 }
+function session(id = 's', owned = true) {
+  return {
+    id,
+    profile: 'p',
+    owned,
+    source: 'web',
+    title: id,
+    messageCount: 0,
+    toolCallCount: 0,
+    startedAt: 1,
+    updatedAt: 1,
+  }
 }
-function emit(type: string, payload: Record<string, unknown> = {}) {
-  realtime.event?.({ type, session_id: 'runtime-1', profile: 'alpha', payload: payload as never })
+function snapshot(messages: any[], id = 's', extra: Partial<TranscriptSnapshot> = {}): TranscriptSnapshot {
+  return {
+    protocol: 'ordinary-chat-transcript-v2',
+    epoch: 'test',
+    cursor: 1,
+    profile: 'p',
+    sessionId: id,
+    messages,
+    session: {},
+    hasOlder: false,
+    total: messages.length,
+    state: 'current',
+    running: false,
+    queued: false,
+    ...extra,
+  }
 }
-
-describe('cross-client chat subscriptions', () => {
+const answer = (content = '规范正文', extra = {}) => ({
+  id: 'canonical-answer',
+  seq: 2,
+  revision: 1,
+  source_message_id: 'upstream',
+  turn_id: 'turn',
+  role: 'assistant',
+  content,
+  status: 'complete',
+  ...extra,
+})
+function emit(type: string, payload: any = {}) {
+  wire.event?.({ type, session_id: 'runtime', profile: 'p', payload })
+}
+describe('ordinary v2 cross-client store', () => {
   let chat: ReturnType<typeof useChatStore>
   beforeEach(() => {
     setActivePinia(createPinia())
-    realtime.request.mockReset().mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1', running: false })
-    api.getMessages.mockReset().mockResolvedValue({ messages: [], total: 0, returned: 0, hasMore: false })
+    wire.owner++
+    wire.clients = []
+    wire.supported = true
+    wire.request
+      .mockReset()
+      .mockResolvedValue({ session_id: 'runtime', stored_session_id: 's', running: false })
+    api.messages.mockReset().mockResolvedValue({ messages: [], total: 0, returned: 0, hasMore: false })
+    api.sessions.mockReset().mockResolvedValue({ items: [session()] })
     chat = useChatStore()
     chat.sessions = [session()]
   })
-  afterEach(() => { chat.disconnect(); vi.useRealTimers() })
-
-  it('subscribes a viewer before another device starts, then shows thinking, tools, text and completion', async () => {
-    await chat.selectSession('stored-1', 'alpha')
-    expect(realtime.request).toHaveBeenCalledExactlyOnceWith('session.resume', {
-      session_id: 'stored-1', profile: 'alpha', source: 'web', omit_messages: true,
-    })
-    expect(chat.sessions[0].updatedAt).toBe(2)
-    emit('message.start')
-    emit('thinking.delta', { text: '正在检查' })
-    expect(chat.isStreaming).toBe(true)
-    expect(chat.activeRouteState?.liveStatus).toBe('正在检查')
-    emit('tool.start', { tool_id: 'tool-1', name: 'read_file' })
-    expect(chat.messages.at(-1)?.toolCalls?.[0]).toMatchObject({ name: 'read_file', status: 'running' })
-    emit('tool.complete', { tool_id: 'tool-1', name: 'read_file', result: 'ok' })
-    emit('message.delta', { text: '检查完成' })
-    expect(chat.messages.at(-1)?.content).toBe('检查完成')
-    emit('message.complete', { text: '检查完成' })
-    expect(chat.isStreaming).toBe(false)
-    expect(chat.activeRouteState?.liveStatus).toBeUndefined()
-    expect(chat.messages.at(-1)?.toolCalls?.[0].status).toBe('completed')
+  afterEach(() => {
+    chat.disconnect()
+    vi.useRealTimers()
   })
-
-  it('restores a run opened before its first text, so tool events are not dropped', async () => {
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1',
-      running: true, inflight: { streaming: true, assistant: '' } })
-    await chat.selectSession('stored-1', 'alpha')
+  async function open(id = 's') {
+    await chat.selectSession(id, 'p')
+    await vi.waitFor(() => expect(wire.clients.some((c) => c.id === id)).toBe(true))
+    return wire.clients.filter((c) => c.id === id).at(-1)!
+  }
+  it('renders only canonical messages and ignores raw upstream bodies and completions', async () => {
+    const client = await open()
+    await client.changed(snapshot([answer('前半', { status: 'streaming' })], 's', { running: true }))
+    emit('message.delta', { text: '不应追加' })
+    emit('message.interim', { text: '不应重复' })
+    emit('message.complete', { text: '不应替换' })
+    expect(chat.messages.map((m) => m.content)).toEqual(['前半'])
     expect(chat.isStreaming).toBe(true)
-    expect(chat.messages).toHaveLength(1)
-    emit('tool.start', { tool_id: 'tool-1', name: 'terminal' })
-    expect(chat.messages[0].toolCalls?.[0].name).toBe('terminal')
-  })
-
-  it('restores a partial answer and appends later deltas without an extra row', async () => {
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1',
-      running: true, inflight: { assistant: '前半段' } })
-    await chat.selectSession('stored-1', 'alpha')
-    emit('message.delta', { text: '后半段' })
-    expect(chat.messages.map(message => message.content)).toEqual(['前半段后半段'])
-  })
-
-  it('resubscribes an idle viewer after disconnection and discovers a remote run', async () => {
-    await chat.selectSession('stored-1', 'alpha')
+    await client.changed(snapshot([answer('完整正文', { revision: 2 })], 's', { cursor: 2 }))
+    expect(chat.messages.map((m) => m.content)).toEqual(['完整正文'])
     expect(chat.isStreaming).toBe(false)
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1',
-      running: true, inflight: { assistant: '断线期间开始的回复' } })
-    vi.useFakeTimers()
-    realtime.state?.('failed')
-    await vi.advanceTimersByTimeAsync(500)
-    expect(realtime.request).toHaveBeenCalledTimes(2)
-    expect(chat.isStreaming).toBe(true)
-    expect(chat.messages.at(-1)?.content).toBe('断线期间开始的回复')
-  })
-
-  it('does not repeatedly resume a subscribed session when revisiting it', async () => {
-    await chat.selectSession('stored-1', 'alpha')
-    await chat.selectSession('stored-1', 'alpha')
-    expect(realtime.request).toHaveBeenCalledTimes(1)
-    expect(api.getMessages).toHaveBeenCalledTimes(1)
-  })
-
-  it('reconciles a background session after cache synchronization before reusing it', async () => {
-    const first = 'background-sync-first', second = 'background-sync-second'
-    chat.sessions = [session(first), session(second)]
-    realtime.request.mockImplementation((_method: string, params: Record<string, string>) => Promise.resolve({
-      session_id: `runtime-${params.session_id}`, stored_session_id: params.session_id, running: false,
-    }))
-    const user = { id: 'user-background', serverMessageId: 'user-background', sessionId: first,
-      role: 'user', content: '第一个问题', timestamp: 1, stage: 'settled' }
-    let synchronized = false
-    api.getMessages.mockImplementation((id: string) => Promise.resolve({
-      messages: id === first ? [user, { id: synchronized ? 'server-final' : 'event:interim',
-        serverMessageId: synchronized ? 'server-final' : undefined, sessionId: first,
-        role: 'assistant', content: synchronized ? '后台完成的完整结果' : '旧的中间结果', timestamp: 2, stage: 'settled' }] : [],
-      total: id === first ? 2 : 0, returned: id === first ? 2 : 0, hasMore: false,
-    }))
-    await chat.selectSession(first, 'alpha')
-    await chat.selectSession(second, 'alpha')
-    synchronized = true
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: first })
-    expect(chat.activeSessionId).toBe(second)
-    expect(chat.messages).toEqual([])
-    await chat.selectSession(first, 'alpha')
-    await vi.waitFor(() => expect(chat.messages.map(message => message.content)).toEqual(['第一个问题', '后台完成的完整结果']))
-    expect(realtime.request.mock.calls.filter(([method]) => method === 'prompt.submit')).toHaveLength(0)
+    expect(api.messages).not.toHaveBeenCalled()
   })
-
-  it('coalesces history invalidations that arrive while an older snapshot is loading', async () => {
-    const id = 'sync-during-history-load'
-    chat.sessions = [session(id)]
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: id, running: false })
-    const page = (text: string) => ({ messages: [{ id: 'answer-sync', serverMessageId: 'answer-sync',
-      sessionId: id, role: 'assistant', content: text, timestamp: 1, stage: 'settled' }], total: 1, returned: 1, hasMore: false })
-    api.getMessages.mockResolvedValue(page('原缓存'))
-    await chat.selectSession(id, 'alpha')
-    let release!: (value: unknown) => void
-    api.getMessages.mockImplementationOnce(() => new Promise(resolve => { release = resolve }))
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: id })
-    await vi.waitFor(() => expect(api.getMessages).toHaveBeenCalledTimes(2))
-    api.getMessages.mockResolvedValue(page('较新完整历史'))
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: id })
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: id })
-    release(page('已过时快照'))
-    await vi.waitFor(() => expect(chat.messages.map(message => message.content)).toEqual(['较新完整历史']))
-    expect(api.getMessages).toHaveBeenCalledTimes(3)
-    await vi.waitFor(() => expect(chat.activeRouteState?.isLoadingHistory).toBe(false))
-    expect(chat.historySynced).toBe(true)
+  it('does not materialize a resume snapshot beside the canonical reply', async () => {
+    wire.request.mockResolvedValue({
+      session_id: 'runtime',
+      stored_session_id: 's',
+      running: true,
+      inflight: { assistant: '旧恢复快照' },
+    })
+    const client = await open()
+    await client.changed(snapshot([answer('当前正文')]))
+    expect(chat.messages.map((m) => m.content)).toEqual(['当前正文'])
+    expect(chat.messages[0]!.id).toBe('canonical-answer')
   })
-
-  it('merges synchronized history into the current route when SSE replaces its state during the read', async () => {
-    const id = 'stream-during-history-load'
-    chat.sessions = [session(id)]
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: id, running: false })
-    const page = (text: string) => ({ messages: [
-      { id: 'prior-user', serverMessageId: 'prior-user', sessionId: id, role: 'user', content: '之前的问题', timestamp: 1, stage: 'settled' },
-      { id: 'prior-answer', serverMessageId: 'prior-answer', sessionId: id, role: 'assistant', content: text, timestamp: 2, stage: 'settled' },
-    ], total: 2, returned: 2, hasMore: false })
-    api.getMessages.mockResolvedValue(page('旧正文'))
-    await chat.selectSession(id, 'alpha')
-    let release!: (value: unknown) => void
-    api.getMessages.mockImplementationOnce(() => new Promise(resolve => { release = resolve }))
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: id })
-    await vi.waitFor(() => expect(api.getMessages).toHaveBeenCalledTimes(2))
-    emit('run.peer_user_message', { message_id: 'live-user', client_message_id: 'live-client', text: '新问题', timestamp: 3, status: 'accepted' })
-    emit('message.start')
-    emit('message.delta', { text: '新回复正在继续' })
-    release(page('之前的完整正文'))
-    await vi.waitFor(() => expect(chat.messages.find(message => message.id === 'prior-answer')?.content).toBe('之前的完整正文'))
-    expect(chat.messages.at(-1)?.content).toBe('新回复正在继续')
-    expect(chat.isStreaming).toBe(true)
-    await vi.waitFor(() => expect(chat.activeRouteState?.isLoadingHistory).toBe(false))
+  it('restores tools and pending interactions from the canonical snapshot', async () => {
+    const client = await open()
+    await client.changed(
+      snapshot(
+        [
+          answer('', {
+            status: 'streaming',
+            tool_calls: [{ id: 'tool', name: 'terminal', status: 'running' }],
+          }),
+        ],
+        's',
+        {
+          running: true,
+          pendingApproval: { request_id: 'approval', message: '允许执行' },
+          pendingClarification: { request_id: 'clarify', question: '请选择' },
+        },
+      ),
+    )
+    expect(chat.messages[0]!.toolCalls?.[0]?.id).toBe('tool')
+    expect(chat.pendingApproval?.id).toBe('approval')
+    expect(chat.pendingClarification?.id).toBe('clarify')
+    await client.changed(
+      snapshot([answer()], 's', { cursor: 2, pendingApproval: null, pendingClarification: null }),
+    )
+    expect(chat.pendingApproval).toBeUndefined()
+    expect(chat.pendingClarification).toBeUndefined()
   })
-
-  it('keeps loaded older messages and follows up a synchronization received during pagination', async () => {
-    const id = 'sync-during-older-page'
-    chat.sessions = [session(id)]
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: id, running: false })
-    const recent = (text: string) => ({ messages: [{ id: 'recent-answer', serverMessageId: 'recent-answer',
-      sessionId: id, role: 'assistant', content: text, timestamp: 2, stage: 'settled' }], total: 2, returned: 1, hasMore: true })
-    api.getMessages.mockResolvedValue(recent('旧的最新页'))
-    await chat.selectSession(id, 'alpha')
-    let release!: (value: unknown) => void
-    api.getMessages.mockImplementationOnce(() => new Promise(resolve => { release = resolve }))
-    const older = chat.loadOlder()
-    await vi.waitFor(() => expect(api.getMessages).toHaveBeenCalledTimes(2))
-    emit('session.info', { model: 'new-model' })
-    api.getMessages.mockResolvedValue(recent('补齐后的最新页'))
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: id })
-    release({ messages: [{ id: 'older-user', serverMessageId: 'older-user', sessionId: id,
-      role: 'user', content: '之前加载的老消息', timestamp: 1, stage: 'settled' }], total: 2, returned: 1, hasMore: false })
-    await older
-    await vi.waitFor(() => expect(chat.messages.map(message => message.content)).toEqual(['之前加载的老消息', '补齐后的最新页']))
-    expect(api.getMessages).toHaveBeenCalledTimes(3)
-    await vi.waitFor(() => expect(chat.activeRouteState?.isLoadingHistory).toBe(false))
+  it('rejects a closed session callback after switching to another conversation', async () => {
+    const first = await open()
+    chat.sessions.push(session('second'))
+    wire.request.mockResolvedValue({ session_id: 'runtime-2', stored_session_id: 'second' })
+    const second = await open('second')
+    await second.changed(snapshot([answer('第二个会话')], 'second'))
+    await first.changed(snapshot([answer('旧回调')]))
+    expect(chat.activeSessionId).toBe('second')
+    expect(chat.messages[0]!.content).toBe('第二个会话')
   })
-
-  it('reconciles synchronized history before a delayed submit receipt without duplicating or demoting the user row', async () => {
-    chat.sessions = [session('identity-session')]
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'identity-session', running: false })
-    await chat.selectSession('identity-session', 'alpha')
-    let accept: (value: unknown) => void = () => {}
-    realtime.request.mockImplementation((method: string) => method === 'prompt.submit'
-      ? new Promise(resolve => { accept = resolve }) : Promise.resolve({}))
-    const sending = chat.send('查看服务器情况')
-    await vi.waitFor(() => expect(realtime.request.mock.calls.some(([method]) => method === 'prompt.submit')).toBe(true))
-    const local = chat.messages.find(message => message.role === 'user')!
-    const persisted = { ...local, id: '1155', serverMessageId: '1155', stage: 'settled' as const }
-    api.getMessages.mockResolvedValue({ messages: [persisted], total: 1, returned: 1, hasMore: false })
-    emit('sessions.changed', { reason: 'cache.synced', profile: 'alpha', session_id: 'identity-session' })
-    await vi.waitFor(() => expect(chat.messages[0]?.id).toBe('1155'))
+  it('does not let a late submit receipt re-open a completed turn or duplicate the user', async () => {
+    const client = await open()
+    let accept!: (value: any) => void
+    wire.request.mockImplementation((method: string) =>
+      method === 'prompt.submit'
+        ? new Promise((resolve) => {
+            accept = resolve
+          })
+        : Promise.resolve({}),
+    )
+    const sending = chat.send('问题')
+    await vi.waitFor(() => expect(accept).toBeTypeOf('function'))
+    const local = chat.messages.find((m) => m.role === 'user')!
+    await client.changed(
+      snapshot(
+        [
+          {
+            id: 'canonical-user',
+            seq: 1,
+            revision: 2,
+            source_message_id: 'persisted-user',
+            client_message_id: local.clientMessageId,
+            role: 'user',
+            content: '问题',
+            status: 'complete',
+          },
+          answer(),
+        ],
+        's',
+        { cursor: 3, running: false },
+      ),
+    )
     accept({ status: 'streaming' })
     await sending
-    expect(chat.messages.filter(message => message.role === 'user')).toHaveLength(1)
-    expect(chat.messages[0]).toMatchObject({ id: '1155', clientMessageId: local.clientMessageId, stage: 'settled' })
-  })
-
-  it('settles a run and clears an interaction completed while the viewer was offline', async () => {
-    await chat.selectSession('stored-1', 'alpha')
-    emit('message.start')
-    emit('message.delta', { text: '部分回复' })
-    emit('thinking.delta', { text: '等待确认' })
-    emit('approval.request', { request_id: 'approval-1' })
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1',
-      running: false, inflight: { assistant: '完整回复', streaming: false } })
-    vi.useFakeTimers()
-    realtime.state?.('failed')
-    await vi.advanceTimersByTimeAsync(500)
+    expect(chat.messages.filter((m) => m.role === 'user')).toHaveLength(1)
+    expect(chat.messages[0]!.stage).toBe('settled')
     expect(chat.isStreaming).toBe(false)
-    expect(chat.messages).toHaveLength(1)
-    expect(chat.messages[0]).toMatchObject({ content: '完整回复', stage: 'settled', isStreaming: false })
-    expect(chat.activeRouteState?.liveStatus).toBeUndefined()
-    expect(chat.pendingApproval).toBeUndefined()
   })
-
-  it('does not duplicate completed history from a retained inactive snapshot', async () => {
-    api.getMessages.mockResolvedValue({ messages: [{ id: 'answer-1', sessionId: 'stored-1',
-      role: 'assistant', content: '已完成回复', timestamp: 1, stage: 'settled' }], total: 1, returned: 1, hasMore: false })
-    realtime.request.mockResolvedValue({ session_id: 'runtime-1', stored_session_id: 'stored-1',
-      running: false, inflight: { assistant: '已完成回复', streaming: false } })
-    await chat.selectSession('stored-1', 'alpha')
-    expect(chat.messages.map(message => message.id)).toEqual(['answer-1'])
+  it('keeps a pending local input during a new generation replacement', async () => {
+    const client = await open()
+    let reject!: (error: Error) => void
+    wire.request.mockImplementation((method: string) =>
+      method === 'prompt.submit'
+        ? new Promise((_resolve, r) => {
+            reject = r
+          })
+        : Promise.resolve({}),
+    )
+    const sending = chat.send('待确认').catch(() => {})
+    await vi.waitFor(() => expect(reject).toBeTypeOf('function'))
+    const local = chat.messages[0]!.id
+    await client.changed(snapshot([answer('历史重建')], 's', { epoch: 'rebuilt' }))
+    expect(chat.messages.some((m) => m.id === local)).toBe(true)
+    reject(new Error('connection lost'))
+    await sending
   })
-
-  it.each([false, undefined])('keeps history-only sessions unattached with owned=%s', async owned => {
-    chat.sessions[0].owned = owned
-    await chat.selectSession('stored-1', 'alpha')
-    realtime.state?.('ready')
-    expect(realtime.request).not.toHaveBeenCalled()
+  it('uses transcript pagination without requesting legacy message pages', async () => {
+    const client = await open()
+    await client.changed(snapshot([answer()], 's', { hasOlder: true }))
+    await chat.loadOlder()
+    expect(client.loadOlder).toHaveBeenCalledOnce()
+    expect(api.messages).not.toHaveBeenCalled()
   })
-
-  it('never creates a runtime for an unsent draft on ready', () => {
-    const id = chat.createSession('alpha')
-    chat.routes[routeKey('alpha', id)].historySynced = true
-    realtime.state?.('ready')
-    expect(realtime.request).not.toHaveBeenCalled()
+  it('requires v2 and never falls back to legacy history for owned chat', async () => {
+    wire.supported = false
+    await expect(chat.selectSession('s', 'p')).rejects.toThrow('升级服务端')
+    expect(api.messages).not.toHaveBeenCalled()
   })
-
-  it('retains readable history when subscribing fails and can retry on selection', async () => {
-    realtime.request.mockRejectedValueOnce(new Error('connection lost'))
-    await chat.selectSession('stored-1', 'alpha')
-    expect(chat.historySynced).toBe(true)
-    expect(chat.activeRouteState?.error).toBe('connection lost')
-    await chat.selectSession('stored-1', 'alpha')
-    expect(chat.activeRouteState?.runtimeSessionId).toBe('runtime-1')
+  it('keeps read-only native history outside the ordinary transcript', async () => {
+    chat.sessions = [session('s', false)]
+    await chat.selectSession('s', 'p')
+    expect(api.messages).toHaveBeenCalledOnce()
+    expect(wire.request).not.toHaveBeenCalled()
   })
 })

+ 2 - 6
tests/client/chatLifecycle.test.ts

@@ -5,15 +5,14 @@ import { normalizeChatMessage } from '@/utils/normalize'
 import { reconcileChatHistory } from '@/utils/chatHistory'
 import { chatMessagesToUi } from '@/components/workspace/viewModels'
 import { buildMessageTimelineRows } from '@/utils/turnTrace'
-import { projectChatEvent } from '../../src/server/chatEventProjection'
 
 function state(): ChatRouteState { return { route: { sessionId: 's', profile: 'p' }, messages: [], isStreaming: false, isQueued: false,
   historySynced: true, hasMoreBefore: false, loadedMessageCount: 0, messageTotal: 0, isLoadingHistory: false, generation: 1 } }
 const user = (id: string): ChatMessage => ({ id, sessionId: 's', role: 'user', content: 'pwd', timestamp: 1, stage: 'settled' })
 
 describe('ordinary tool lifecycle and authoritative history', () => {
-  it('counts one invocation across generating/start/complete in both realtime and durable projection', () => {
-    let current = state(), durable: Record<string, any> | undefined
+  it('counts one invocation across generating/start/complete in legacy history presentation', () => {
+    let current = state()
     for (const [type, payload] of [
       ['message.start', {}], ['tool.generating', { name: 'terminal' }],
       ['tool.start', { tool_id: 'call-1', name: 'terminal', args: { command: 'pwd' } }],
@@ -21,11 +20,8 @@ describe('ordinary tool lifecycle and authoritative history', () => {
       ['message.complete', { text: '/work', status: 'complete' }],
     ] as Array<[string, any]>) {
       current = applyChatEvent(current, { type, payload })
-      durable = projectChatEvent(type, payload, durable, 'event:1', 1000) ?? durable
     }
     expect(current.messages.flatMap(message => message.toolCalls ?? [])).toHaveLength(1)
-    expect(durable!.tool_calls).toHaveLength(1)
-    expect(durable!.tool_calls[0].status).toBe('completed')
     expect(buildMessageTimelineRows(chatMessagesToUi(current.messages)).filter(row => row.kind === 'trace').map(row => row.status)).toEqual(['success'])
   })
 

+ 1 - 1
tests/client/chatProtocol.test.ts

@@ -11,7 +11,7 @@ function httpFixture() {
   const send = (frame: object) => stream!.enqueue(new TextEncoder().encode('event: frame\ndata: ' + JSON.stringify(frame) + '\n\n'))
   const fetchMock = vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
     const path = String(input)
-    if (path.endsWith('/capabilities')) return Response.json({ protocolVersion: 1, csrfToken: 'csrf-test' })
+    if (path.endsWith('/capabilities')) return Response.json({ protocolVersion: 1, csrfToken: 'csrf-test', features:['ordinary-chat-transcript-v2'] })
     if (init?.method === 'DELETE') return new Response(null, { status: 204 })
     if (path.endsWith('/channels')) {
       const body = JSON.parse(String(init?.body)); kind = body.channel; epoch = body.epoch; cursor = body.cursor

+ 19 - 0
tests/client/localVmImages.test.ts

@@ -7,6 +7,25 @@ vi.mock('../../src/client/api/client',()=>({apiRequest:vi.fn()}))
 const images=[{key:'standard',name:'标准桌面',description:'XFCE',ready:true,imageId:'sha256:a'},{key:'cursor',name:'Cursor Universal',description:'Debian',ready:true,imageId:'sha256:b'}]
 const agent={id:'image-fixture',name:'镜像测试',computer:'vm',execution:'computer',nodeId:'local',profile:'default'} as any
 const vm={configured:true,runtime:'docker',daemonUp:true,image:true,mode:'per-bot',maxInstances:2,busy:false,images}
+it('selects Profile collaboration without changing the VM and locks the mode while it is in use',async()=>{
+ vi.spyOn(document,'hidden','get').mockReturnValue(false)
+ let inUse=false
+ vi.mocked(apiRequest).mockImplementation(async path=>{
+  if(path.endsWith('/desktop-environment'))return {selected:null,local:{supported:false},browser:{available:false}} as any
+  if(path.endsWith('/cloud-computer'))return {configured:false} as any
+  return {...vm,enabled:true,container:'missing',ready:false,inUse} as any
+ })
+ const wrapper=mount(Panel,{props:{agents:[agent],isAdmin:true,active:true},global:{stubs:{AppIcon:true,GrokAuthPanel:true}}})
+ try{
+  await flushPromises();await wrapper.get('[aria-label="本地虚拟机执行方式"]').setValue('profile');await flushPromises()
+  expect(apiRequest).toHaveBeenCalledWith('/api/app/agents/image-fixture/computer-selection',{method:'PUT',body:{computer:'vm',vmExecution:'profile',allowHostEnvironment:true}})
+  await wrapper.setProps({agents:[{...agent,vmExecution:'profile',allowHostEnvironment:true}]});await flushPromises()
+  expect(wrapper.text()).toContain('使用基础机器人的完整本机环境')
+  expect(wrapper.find('.host-environment-option').exists()).toBe(false)
+  inUse=true;await wrapper.setProps({active:false});await wrapper.setProps({active:true});await flushPromises()
+  expect((wrapper.get('[aria-label="本地虚拟机执行方式"]').element as HTMLSelectElement).disabled).toBe(true)
+ }finally{wrapper.unmount()}
+})
 afterEach(()=>{vi.clearAllMocks();vi.restoreAllMocks()})
 it('saves never-stop and restores the selected value after refresh',async()=>{
  let idleStopMinutes=5

+ 112 - 0
tests/client/ordinaryTranscriptV2.test.ts

@@ -0,0 +1,112 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import fixture from '../fixtures/ordinary-chat-v2/protocol.json'
+import { ChatTranscriptClient } from '@/api/chatTranscript'
+import type { TranscriptSnapshot } from '@shared/chatTranscript'
+const api = vi.hoisted(() => ({ request: vi.fn() }))
+vi.mock('@/api/client', () => ({ apiRequest: api.request }))
+describe('ordinary v2 durable Web replica', () => {
+  beforeEach(() => {
+    api.request.mockReset()
+  })
+  function setup() {
+    const changed = vi.fn().mockResolvedValue(undefined),
+      client = new ChatTranscriptClient('p', 's', changed, vi.fn()) as any
+    client.restore(structuredClone(fixture.snapshot))
+    return { client, changed }
+  }
+  it('converges on the common fixture and does not resurrect a deletion from a delayed page', async () => {
+    const { client, changed } = setup()
+    let release!: (value: unknown) => void
+    api.request.mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          release = resolve
+        }),
+    )
+    const older = client.loadOlder()
+    for (const event of fixture.events) await client.receive(event)
+    release(fixture.stalePage)
+    await older
+    expect(changed.mock.lastCall![0]).toMatchObject({
+      cursor: 4,
+      messages: fixture.expectedMessages,
+      deletedIds: ['old-preview'],
+    })
+  })
+  it('does not advance messages or cursor when persistence fails, and can retry exactly once', async () => {
+    const { client, changed } = setup()
+    changed.mockRejectedValueOnce(new Error('disk full'))
+    await expect(client.receive(fixture.events[0])).rejects.toThrow('disk full')
+    expect(client.snapshot).toEqual(fixture.snapshot)
+    await client.receive(fixture.events[0])
+    await client.receive(fixture.events[0])
+    expect(client.snapshot.messages[0].content).toBe('前半段后半段')
+    expect(client.snapshot.cursor).toBe(2)
+  })
+  it('rejects gaps and old generations without corrupting its checkpoint', async () => {
+    const { client } = setup()
+    await expect(client.receive(fixture.events[2])).rejects.toThrow('版本不连续')
+    await expect(client.receive({ ...fixture.events[0], epoch: 'old' })).rejects.toThrow('版本不连续')
+    expect(client.snapshot).toEqual(fixture.snapshot)
+  })
+  it('discards v1 checkpoints rather than merging them into v2', () => {
+    const client = new ChatTranscriptClient(
+      'p',
+      's',
+      async () => {},
+      () => {},
+    ) as any
+    client.restore({
+      ...fixture.snapshot,
+      protocol: 'ordinary-chat-transcript-v1',
+    } as unknown as TranscriptSnapshot)
+    expect(client.snapshot).toBeUndefined()
+  })
+  it('reopens an inactive event connection without dropping the durable cursor', async () => {
+    vi.useFakeTimers()
+    const { client } = setup()
+    const fetchMock = vi.fn(
+      (_url: unknown, options: RequestInit) =>
+        new Promise((_resolve, reject) => {
+          options.signal?.addEventListener('abort', () => reject(new Error('inactive stream')), {
+            once: true,
+          })
+        }),
+    )
+    vi.stubGlobal('fetch', fetchMock)
+    const running = client.run()
+    try {
+      await vi.advanceTimersByTimeAsync(46_000)
+      expect(fetchMock).toHaveBeenCalledTimes(2)
+      expect(client.snapshot.cursor).toBe(1)
+      expect(fetchMock.mock.calls[1]![1].headers).toMatchObject({ 'Last-Event-ID': 'fixture-epoch:1' })
+    } finally {
+      client.close()
+      await running
+      vi.unstubAllGlobals()
+      vi.useRealTimers()
+    }
+  })
+  it('restores running state and interactions before resuming the saved event cursor', async () => {
+    const { client, changed } = setup()
+    const saved = { ...fixture.snapshot, running: true, liveStatus: '正在思考', pendingApproval: { id: 'approval' } }
+    client.restore(saved)
+    const fetchMock = vi.fn((_url: unknown, options: RequestInit) => {
+      expect(changed).toHaveBeenCalledWith(saved)
+      return new Promise((_resolve, reject) => {
+        options.signal?.addEventListener('abort', () => reject(new Error('closed')), { once: true })
+      })
+    })
+    vi.stubGlobal('fetch', fetchMock)
+    const running = client.run()
+    try {
+      await vi.waitFor(() => expect(fetchMock).toHaveBeenCalledTimes(1))
+      expect(api.request).not.toHaveBeenCalled()
+      expect(fetchMock.mock.calls[0]![1].headers).toMatchObject({ 'Last-Event-ID': 'fixture-epoch:1' })
+    } finally {
+      client.close()
+      await running
+      vi.unstubAllGlobals()
+    }
+  })
+})

+ 40 - 0
tests/client/scopedCache.test.ts

@@ -0,0 +1,40 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { reactive } from 'vue'
+
+const storage = vi.hoisted(() => ({ records: new Map<string, unknown>(), fail: false }))
+vi.mock('idb', () => ({ openDB: async () => ({
+  put: async (_store: string, value: unknown, key: string) => {
+    if (storage.fail) throw new Error('disk unavailable')
+    storage.records.set(key, structuredClone(value))
+  },
+  get: async (_store: string, key: string) => {
+    if (storage.fail) throw new Error('disk unavailable')
+    return structuredClone(storage.records.get(key))
+  },
+}) }))
+
+afterEach(() => { storage.records.clear(); storage.fail = false; vi.unstubAllGlobals(); vi.resetModules() })
+
+it('durably stores reactive pending messages as detached snapshots', async () => {
+  vi.stubGlobal('indexedDB', {})
+  const { ScopedCache } = await import('../../src/client/utils/cache')
+  const cache = new ScopedCache<{ messages: Array<{ content: string }>; cursor: number }>('reactive')
+  const pending = reactive({ content: 'pending input' })
+  const value = reactive({ messages: [pending], cursor: 3 })
+  await cache.set('account', 'session', value, true)
+  pending.content = 'later edit'
+  value.cursor = 4
+  expect(await cache.get('account', 'session')).toEqual({ messages: [{ content: 'pending input' }], cursor: 3 })
+})
+
+it('does not advance the memory checkpoint when durable storage fails', async () => {
+  vi.stubGlobal('indexedDB', {})
+  const { ScopedCache } = await import('../../src/client/utils/cache')
+  const cache = new ScopedCache<{ cursor: number }>('failed-write')
+  const value = reactive({ cursor: 3 })
+  await cache.set('account', 'session', value, true)
+  storage.fail = true
+  value.cursor = 4
+  await expect(cache.set('account', 'session', value, true)).rejects.toThrow('disk unavailable')
+  expect(await cache.get('account', 'session')).toEqual({ cursor: 3 })
+})

+ 18 - 0
tests/e2e/team-tools.spec.ts

@@ -231,6 +231,24 @@ test('persists idle-stop settings and the host environment checkbox on desktop a
  await dock.getByRole('tab',{name:'本地虚拟机',exact:true}).click();await expect(hostOption).not.toBeChecked()
  expect((await(await page.request.get('/api/app/agents')).json()).agents.find((a:any)=>a.id===seed.agentId)).toMatchObject({computer:'vm',execution:'computer',allowHostEnvironment:false})
 })
+test('selects local VM Profile collaboration and preserves it after reload on desktop and phone',async({page},testInfo)=>{
+ await login(page,true)
+ await page.request.post('/__test/hybrid-runner',{data:{}})
+ const seed=await(await page.request.post('/__test/computer?off=1',{data:{}})).json()
+ await page.goto(`/conversations/${seed.conversationId}`);await page.getByRole('button',{name:'电脑与定时任务',exact:true}).click()
+ const dock=page.getByRole('complementary',{name:'机器人电脑面板'}),mode=dock.getByRole('combobox',{name:'本地虚拟机执行方式',exact:true})
+ await mode.selectOption('profile');await expect(mode).toHaveValue('profile')
+ await expect(dock.getByRole('tab',{name:'本地虚拟机',exact:true})).toHaveAttribute('aria-selected','true')
+ await expect(dock).toContainText('使用基础机器人的完整本机环境')
+ await expect(dock.getByRole('checkbox',{name:'允许本机环境',exact:true})).toHaveCount(0)
+ expect((await(await page.request.get('/api/app/agents')).json()).agents.find((a:any)=>a.id===seed.agentId)).toMatchObject({computer:'vm',execution:'computer',vmExecution:'profile',allowHostEnvironment:true})
+ await mode.scrollIntoViewIfNeeded();await page.screenshot({path:testInfo.outputPath('profile-vm-desktop.png')})
+ await page.reload();await page.getByRole('button',{name:'电脑与定时任务',exact:true}).click();await expect(mode).toHaveValue('profile')
+ await page.setViewportSize({width:390,height:844});await page.emulateMedia({colorScheme:'dark',reducedMotion:'reduce'})
+ await mode.scrollIntoViewIfNeeded();await page.screenshot({path:testInfo.outputPath('profile-vm-phone.png')})
+ expect(await page.evaluate(()=>document.documentElement.scrollWidth)).toBeLessThanOrEqual(390)
+ await mode.selectOption('worker');await expect(dock.getByRole('checkbox',{name:'允许本机环境',exact:true})).not.toBeChecked()
+})
 test('cloud VM keeps its own selection while the host option can be checked and clears on auto',async({page},testInfo)=>{
  await login(page,true)
  const seed=await(await page.request.post('/__test/cloud-host-option',{data:{}})).json()

+ 1 - 1
tests/e2e/workspace-chat.spec.ts

@@ -168,7 +168,7 @@ test('an idle Web viewer follows an iOS-origin run and restores thinking after r
   await login(page)
   const capabilities = await (await page.request.get('/api/realtime/capabilities')).json()
   const headers = { 'X-CSRF-Token': capabilities.csrfToken, Origin: new URL(page.url()).origin }
-  const opened = await page.request.post('/api/realtime/channels', { headers, data: { channel: 'chat' } })
+  const opened = await page.request.post('/api/realtime/channels', { headers, data: { channel: 'chat', chatProtocol: 'ordinary-chat-transcript-v2' } })
   expect(opened.ok(), await opened.text()).toBe(true)
   const channel = (await opened.json()).id
   let sequence = 0

+ 11 - 11
tests/e2e/workspace.spec.ts

@@ -706,7 +706,7 @@ test.skip('selects existing group topics and creates a new protocol v4 topic on
 
 test('renders persisted user file markers as attachment cards', async ({ page }) => {
   await page.goto('/chat/session-demo?profile=yaoyao')
-  const userMessage = page.locator('[data-message-id="message-user-file"]')
+  const userMessage = page.locator('.message--user').filter({ hasText: '查看附件' })
   await expect(userMessage).toContainText('查看附件')
   await expect(userMessage.getByRole('button', { name: /测试报告\.docx/ })).toBeVisible()
   await expect(userMessage).not.toContainText('@file:')
@@ -715,7 +715,7 @@ test('renders persisted user file markers as attachment cards', async ({ page })
 
 test('renders persisted user image markers as direct images instead of file cards', async ({ page }) => {
   await page.goto('/chat/session-demo?profile=yaoyao')
-  const userMessage = page.locator('[data-message-id="message-user-image"]')
+  const userMessage = page.locator('.message--user').filter({ has: page.locator('img[alt="测试图片.png"]') })
   const imageAttachment = userMessage.locator('.message__attachment--image')
   await expect(imageAttachment).toBeVisible()
   await expect(imageAttachment.locator('img[alt="测试图片.png"]')).toBeVisible()
@@ -782,7 +782,7 @@ test('renders subtask completion as a collapsed timeline event', async ({ page }
 
 test('renders background process exits as collapsed system events', async ({ page }) => {
   await page.goto('/chat/session-demo')
-  const event = page.locator('[data-message-id="message-background-process"] .background-process-event')
+  const event = page.locator('.background-process-event')
   const detail = event.locator('.markdown')
   await expect(event).toContainText('后台子任务已终止 · SIGTERM')
   await expect(event).not.toHaveAttribute('open', '')
@@ -790,19 +790,19 @@ test('renders background process exits as collapsed system events', async ({ pag
   await event.locator('summary').click()
   await expect(detail).toBeVisible()
   await expect(detail).toContainText('Command: ./run_mac.sh')
-  await expect(page.locator('[data-message-id="message-background-process"]')).toHaveClass(/message--system/)
+  await expect(page.locator('.message').filter({ has: page.locator('.background-process-event') })).toHaveClass(/message--system/)
 })
 
 test('renders context compaction as a collapsed timeline event', async ({ page }) => {
   await page.goto('/chat/session-demo')
-  const compaction = page.locator('[data-message-id="message-compaction"] .compaction-event')
+  const compaction = page.locator('.compaction-event')
   await expect(compaction).toContainText('上下文已压缩')
   await expect(compaction).toContainText('压缩摘要已归档 · 点击查看')
   await expect(compaction).not.toHaveAttribute('open', '')
   await expect(compaction.getByText('Historical Task Snapshot', { exact: true })).toBeHidden()
   await compaction.locator('summary').click()
   await expect(compaction.getByText('Historical Task Snapshot', { exact: true })).toBeVisible()
-  await expect(page.locator('[data-message-id="message-compaction"]')).toHaveClass(/message--system/)
+  await expect(page.locator('.message').filter({ has: page.locator('.compaction-event') })).toHaveClass(/message--system/)
 })
 
 test('renders model changes as a collapsed system event', async ({ page }) => {
@@ -928,7 +928,7 @@ test('keeps the canonical logo and yaoyao-webui composer geometry', async ({ pag
   await expect(outline.getByText('请检查今天生成的产物。MEDIA:/brand/AppIcon-1024.png', { exact: true })).toBeVisible()
   await expect(outline.getByText('验收摘要', { exact: true })).toBeVisible()
   await outline.getByRole('button', { name: '跳转到 验收摘要' }).click()
-  await expect(page.locator('[data-message-id="message-assistant"]')).toHaveClass(/message--revealed/)
+  await expect(page.locator('.message--assistant').filter({ hasText: '验收摘要' })).toHaveClass(/message--revealed/)
   await page.getByRole('button', { name: '关闭会话大纲' }).click()
   await expect(outline).toBeHidden()
   await page.getByRole('button', { name: '会话操作' }).click()
@@ -1070,15 +1070,15 @@ test('renders the Kanban snapshot and mobile status control without page overflo
   expect(geometry.board).toBeGreaterThan(geometry.viewport)
 })
 
-test('serves cached chat history locally and refreshes upstream only on explicit action', async ({ page }, testInfo) => {
-  const messagesURL = (url: string) => url.includes('/api/app/sessions/session-demo/messages')
+test('serves canonical chat snapshots and supports explicit history verification', async ({ page }, testInfo) => {
+  const messagesURL = (url: string) => url.includes('/api/app/chat/sessions/session-demo/snapshot')
   const initial = page.waitForResponse(response => messagesURL(response.url()))
   await page.goto('/chat/session-demo?profile=yaoyao')
   expect((await initial).ok()).toBe(true)
   await expect(page.getByRole('button', { name: '会话操作', exact: true })).toBeVisible()
-  const restored = page.waitForResponse(response => messagesURL(response.url()))
+  const restored = page.waitForResponse(response => response.url().includes('/api/app/chat/sessions/session-demo/events?'))
   await page.reload()
-  expect((await restored).headers()['x-yaoyao-data-source']).toBe('local')
+  expect((await restored).headers()['content-type']).toContain('text/event-stream')
   await page.getByRole('button', { name: '会话操作', exact: true }).click()
   await expect(page.getByRole('menuitem', { name: '强制刷新历史' })).toBeVisible()
   await expect(page.getByRole('menu', { name: '会话操作' })).toHaveCSS('opacity', '1')

+ 135 - 0
tests/fixtures/ordinary-chat-v2/protocol.json

@@ -0,0 +1,135 @@
+{
+  "protocol": "ordinary-chat-transcript-v2",
+  "snapshot": {
+    "protocol": "ordinary-chat-transcript-v2",
+    "epoch": "fixture-epoch",
+    "cursor": 1,
+    "profile": "p",
+    "sessionId": "s",
+    "messages": [
+      {
+        "id": "answer",
+        "source_message_id": "upstream-a",
+        "turn_id": "turn-1",
+        "segment_kind": "answer",
+        "seq": 2,
+        "revision": 1,
+        "role": "assistant",
+        "content": "前半段",
+        "reasoning": "思考",
+        "status": "streaming"
+      }
+    ],
+    "session": {},
+    "hasOlder": true,
+    "total": 2,
+    "state": "current",
+    "running": true,
+    "queued": false
+  },
+  "events": [
+    {
+      "cursor": 2,
+      "previousCursor": 1,
+      "epoch": "fixture-epoch",
+      "profile": "p",
+      "sessionId": "s",
+      "type": "message.patch",
+      "total": 2,
+      "data": {
+        "id": "answer",
+        "seq": 2,
+        "baseRevision": 1,
+        "revision": 2,
+        "contentAppend": "后半段",
+        "reasoningAppend": "继续"
+      }
+    },
+    {
+      "cursor": 2,
+      "previousCursor": 1,
+      "epoch": "fixture-epoch",
+      "profile": "p",
+      "sessionId": "s",
+      "type": "message.patch",
+      "total": 2,
+      "data": {
+        "id": "answer",
+        "seq": 2,
+        "baseRevision": 1,
+        "revision": 2,
+        "contentAppend": "后半段",
+        "reasoningAppend": "继续"
+      }
+    },
+    {
+      "cursor": 3,
+      "previousCursor": 2,
+      "epoch": "fixture-epoch",
+      "profile": "p",
+      "sessionId": "s",
+      "type": "message.upsert",
+      "total": 2,
+      "data": {
+        "id": "answer",
+        "source_message_id": "persisted-42",
+        "turn_id": "turn-1",
+        "segment_kind": "answer",
+        "seq": 2,
+        "revision": 3,
+        "role": "assistant",
+        "content": "前半段后半段",
+        "reasoning": "思考继续",
+        "status": "complete",
+        "final_result": true
+      }
+    },
+    {
+      "cursor": 4,
+      "previousCursor": 3,
+      "epoch": "fixture-epoch",
+      "profile": "p",
+      "sessionId": "s",
+      "type": "message.deleted",
+      "total": 1,
+      "data": { "id": "old-preview", "seq": 1, "revision": 2 }
+    }
+  ],
+  "stalePage": {
+    "protocol": "ordinary-chat-transcript-v2",
+    "epoch": "fixture-epoch",
+    "cursor": 1,
+    "profile": "p",
+    "sessionId": "s",
+    "messages": [
+      {
+        "id": "old-preview",
+        "seq": 1,
+        "revision": 1,
+        "role": "assistant",
+        "content": "前半段",
+        "status": "complete"
+      }
+    ],
+    "deletedIds": [],
+    "session": {},
+    "hasOlder": false,
+    "total": 2,
+    "state": "current"
+  },
+  "expectedMessages": [
+    {
+      "id": "answer",
+      "source_message_id": "persisted-42",
+      "turn_id": "turn-1",
+      "segment_kind": "answer",
+      "seq": 2,
+      "revision": 3,
+      "role": "assistant",
+      "content": "前半段后半段",
+      "reasoning": "思考继续",
+      "status": "complete",
+      "final_result": true
+    }
+  ]
+}

+ 1 - 1
tests/fixtures/workspace-server.ts

@@ -470,7 +470,7 @@ runtime.runners.localVm=async(owner,id,p)=>{
  return {...vmFixture}
 }
 runtime.app.use((ctx,next)=>{if(ctx.path!=='/__test/local-vm')return next();const owner=auth.requireAdmin(ctx).id;vmFixture.image=ctx.query.ready==='1';vmFixture.mode='per-bot';vmFixture.maxInstances=2;vmFixture.idleStopMinutes=5;vmFixture.job=undefined;(runtime.runners as any).online.delete(vmRunnerId);if(!vmRunnerId){for(const record of runtime.runners.records())if(record.sourceNodeId==='local'&&record.enabled)runtime.runners.remove(record.id);vmRunnerId=runtime.runners.enroll(owner,{name:'本机虚拟机',allowedProfiles:['default']}).runner.id;}ctx.body={runnerId:vmRunnerId}})
-runtime.app.use((ctx,next)=>{if(ctx.path!=='/__test/hybrid-runner')return next();auth.requireAdmin(ctx);(runtime.runners as any).online.set(vmRunnerId,{instance:randomUUID(),epoch:'fixture',seen:Date.now(),features:['computer-worker-v1','computer-control-v1','local-vm-v1','image-ready-v1','host-computer-tools-v1','idle-stop-policy-v1']});ctx.body={ok:true}})
+runtime.app.use((ctx,next)=>{if(ctx.path!=='/__test/hybrid-runner')return next();auth.requireAdmin(ctx);(runtime.runners as any).online.set(vmRunnerId,{instance:randomUUID(),epoch:'fixture',seen:Date.now(),features:['computer-worker-v1','computer-control-v1','local-vm-v1','image-ready-v1','host-computer-tools-v1','idle-stop-policy-v1','profile-computer-v1']});ctx.body={ok:true}})
 runtime.app.use((ctx,next)=>{
  if(ctx.path!=='/__test/cloud-host-option')return next();const owner=auth.requireAdmin(ctx).id,cloud=runtime.workspaceRuntime.cloud!
  cloud.state=async()=>({configured:true,running:false});cloud.status=async()=>({backend:'grok',mode:'off'});cloud.requireAvailable=async()=>{};cloud.connect=async()=>({} as any)

+ 65 - 0
tests/live/profileComputer.live.test.ts

@@ -0,0 +1,65 @@
+// @vitest-environment node
+import {expect,it} from 'vitest'
+import {createServer} from 'node:http'
+import {spawn} from 'node:child_process'
+import {DatabaseSync} from 'node:sqlite'
+import {mkdtemp,mkdir,cp,writeFile,rm} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join,resolve} from 'node:path'
+import {randomUUID} from 'node:crypto'
+import {ComputerGateway,ComputerRuntime} from '../../src/runner/worker/gateway'
+import {UpstreamClient} from '../../src/server/upstream'
+import {UpstreamServiceSession} from '../../src/server/localAuth'
+
+const available=['YAOYAO_HERMES_PYTHON','YAOYAO_HERMES_SOURCE','YAOYAO_PROFILE_BRIDGE','YAOYAO_COMPUTER_IMAGE'].every(name=>!!process.env[name])
+it.skipIf(!available)('runs a real Hermes Profile with native tools and a real Docker VM through the cloud-style bridge',async()=>{
+ const home=await mkdtemp(join(tmpdir(),'yaoyao-profile-live-')),workspace=join(home,'workspace'),db=new DatabaseSync(':memory:')
+ await mkdir(workspace);await mkdir(join(home,'plugins'))
+ await cp(process.env.YAOYAO_PROFILE_BRIDGE!,join(home,'plugins','yaoyao-bot-bridge'),{recursive:true})
+ await writeFile(join(workspace,'AGENTS.md'),'PROFILE_CONTEXT_MARKER: use only the fixture files and the assigned test virtual machine.\n')
+ const requests:any[]=[],results:any[]=[]
+ let step=0
+ const model=createServer(async(req,res)=>{
+  let body='';for await(const part of req)body+=part
+  res.setHeader('Content-Type','application/json')
+  if(req.method==='GET'){res.end(JSON.stringify({data:[{id:'fixture-profile-model',context_length:65536}]}));return}
+  const input=JSON.parse(body);requests.push(input)
+  const tools=input.tools??[];let tool:string|undefined,args:any
+  if(tools.length){
+   results.push(...input.messages.filter((m:any)=>m.role==='tool'))
+   const operation=[['terminal',{command:'printf native-profile-proof',timeout:10}],['yaoyao_computer_shell_',{command:'printf vm-profile-proof > proof.txt; uname -s'}],['yaoyao_computer_read_file_',{path:'proof.txt'}]][step]
+   if(operation){tool=tools.find((t:any)=>t.function.name===operation[0]||t.function.name.startsWith(operation[0]))?.function.name;args=operation[1];if(tool)step++}
+  }
+  const message=tool?{role:'assistant',content:null,tool_calls:[{id:randomUUID(),type:'function',function:{name:tool,arguments:JSON.stringify(args)}}]}:{role:'assistant',content:tools.length?'本机与虚拟机协作完成':'fixture'}
+  if(input.stream){res.setHeader('Content-Type','text/event-stream');res.end('data: '+JSON.stringify({id:randomUUID(),object:'chat.completion.chunk',model:'fixture-profile-model',choices:[{index:0,delta:message,finish_reason:tool?'tool_calls':'stop'}]})+'\n\ndata: [DONE]\n\n')}
+  else res.end(JSON.stringify({id:randomUUID(),object:'chat.completion',model:'fixture-profile-model',choices:[{index:0,message,finish_reason:tool?'tool_calls':'stop'}],usage:{prompt_tokens:100,completion_tokens:30,total_tokens:130}}))
+ })
+ await new Promise<void>(done=>model.listen(0,'127.0.0.1',done))
+ const modelURL=`http://127.0.0.1:${(model.address() as {port:number}).port}/v1`
+ await writeFile(join(home,'config.yaml'),JSON.stringify({model:{default:'fixture-profile-model',provider:'custom',base_url:modelURL,api_key:'fixture',context_length:65536,max_tokens:4096},terminal:{cwd:workspace},plugins:{enabled:['yaoyao-bot-bridge']},toolsets:['all'],tools:{tool_search:{enabled:'off'}},dashboard:{turn_isolation:false},compression:{enabled:false},memory:{memory_enabled:false,user_profile_enabled:false}}))
+ const reservation=createServer();await new Promise<void>(done=>reservation.listen(0,'127.0.0.1',done))
+ const port=(reservation.address() as {port:number}).port;await new Promise<void>(done=>reservation.close(()=>done()))
+ const url=new URL(`http://127.0.0.1:${port}`),source=process.env.YAOYAO_HERMES_SOURCE!,python=process.env.YAOYAO_HERMES_PYTHON!
+ let logs=''
+ const child=spawn(python,['-m','hermes_cli.main','serve','--host','127.0.0.1','--port',String(port),'--skip-build','--isolated'],{cwd:workspace,env:{PATH:process.env.PATH,HOME:process.env.HOME,LANG:'en_US.UTF-8',HERMES_HOME:home,PYTHONPATH:source,HERMES_DASHBOARD_SESSION_TOKEN:'fixture-local-profile-token-123456789',HERMES_YOLO_MODE:'1',NO_PROXY:'127.0.0.1,localhost'},stdio:['ignore','pipe','pipe']})
+ child.stdout.on('data',c=>{logs=(logs+String(c)).slice(-16000)});child.stderr.on('data',c=>{logs=(logs+String(c)).slice(-16000)})
+ const client=new UpstreamClient(url),target={url,client,session:new UpstreamServiceSession(client,()=>undefined)}
+ const runtime=new ComputerRuntime(db,{protocol:1,runnerId:randomUUID(),serverURL:url.href,hermesURL:url.href,token:'fixture',allowedProfiles:['default'],artifactRoots:[],computers:{runtime:'docker',imageId:process.env.YAOYAO_COMPUTER_IMAGE!,python,hermesSource:source,hermesHome:home,network:'none'}},home,resolve('src/runner/worker/hermes_worker.py'))
+ const id=randomUUID(),gateway=new ComputerGateway(runtime,{environmentId:id,agentId:id,ownerKey:'profile-live-fixture',hostAccess:true,profileSession:true},randomUUID(),async()=>{},async()=>({}),target)
+ try{
+  await expect.poll(async()=>{if(child.exitCode!==null)throw new Error(logs);try{return(await fetch(new URL('/api/status',url))).status}catch{return 0}},{timeout:45000}).toBe(200)
+  const complete=new Promise<any>((done,reject)=>{gateway.onEvent=frame=>{if(frame.type==='message.complete')done(frame.payload)};gateway.onDisconnect=()=>reject(new Error('Profile disconnected\n'+logs))})
+  void complete.catch(()=>{})
+  await gateway.connect();const opened=await gateway.rpc('session.create',{profile:'default'})
+  await gateway.rpc('prompt.submit',{session_id:opened.session_id,text:'依次执行本机终端、虚拟机命令、读取虚拟机文件,然后报告完成。'})
+  const result=await complete
+  expect(result.text,logs).toBe('本机与虚拟机协作完成');expect(step,JSON.stringify(requests.map(r=>r.tools?.map((t:any)=>t.function.name)))).toBe(3)
+  expect(JSON.stringify(results)).toContain('native-profile-proof');expect(JSON.stringify(results)).toContain('vm-profile-proof');expect(JSON.stringify(results)).toContain('Linux')
+  expect(JSON.stringify(requests.filter(r=>r.tools?.length).map(r=>r.messages))).toContain('PROFILE_CONTEXT_MARKER')
+  expect(runtime.workers.size).toBe(0)
+ }finally{
+  await gateway.close().catch(()=>{});await runtime.controls.close();await runtime.pool.close();db.close();client.close()
+  child.kill('SIGTERM');await new Promise<void>(done=>{if(child.exitCode!==null){done();return}const timer=setTimeout(()=>child.kill('SIGKILL'),5000);child.once('exit',()=>{clearTimeout(timer);done()})})
+  await new Promise<void>(done=>{model.close(()=>done());model.closeAllConnections()});await rm(home,{recursive:true,force:true})
+ }
+},120000)

+ 12 - 12
tests/server/chatCache.test.ts

@@ -354,12 +354,12 @@ describe('durable source=web chat cache', () => {
       pagination: { total: 2, returned: 2, offset: 0, limit: 100, hasMore: false },
     }))
 
-    const page = f.store.messagePage(owner, profile, sessionID, 0, 100)
+    const page = f.store.sourceMessagePage(owner, profile, sessionID, 0, 100)
     const payload = JSON.parse(page!.response.body.toString())
     expect(payload.session_id).toBe(sessionID)
     expect(payload.pagination).toMatchObject({ total: 2, returned: 2, offset: 0, limit: 100, has_more: false })
     expect(payload.messages.map((item: { id: string }) => item.id)).toEqual(['m1', 'm2'])
-    expect(f.store.messagePage('another-owner', profile, sessionID, 0, 100)).toBeUndefined()
+    expect(f.store.sourceMessagePage('another-owner', profile, sessionID, 0, 100)).toBeUndefined()
     f.store.close()
   })
 
@@ -465,7 +465,7 @@ describe('durable source=web chat cache', () => {
       pagination: { total: 1, returned: 1, offset: 0, limit: 100, hasMore: false },
     }))).toBe(true)
 
-    const page = f.store.messagePage(owner, profile, ownedSessionID, 0, 100)
+    const page = f.store.sourceMessagePage(owner, profile, ownedSessionID, 0, 100)
     expect(JSON.parse(page!.response.body.toString())).toMatchObject({
       session_id: ownedSessionID,
       session: { source: 'ios', title: 'iOS 权威标题' },
@@ -648,10 +648,10 @@ describe('local history and bounded tail synchronization', () => {
     coordinator.observe(owner, profile, sessionID, { type: 'message.complete', seq: 1 })
     await coordinator.reconcile(owner, profile, sessionID)
     const page = await coordinator.messages(owner, 'last', profile, sessionID, 0, 10, async () => { throw new Error('unexpected read') })
-    expect(JSON.parse(page.response.body.toString()).messages.at(-1).id).toBe('new-answer')
+    expect(JSON.parse(page.response.body.toString()).messages.at(-1).source_message_id).toBe('new-answer')
     expect(request.mock.calls.filter(([path]) => path.endsWith('/messages'))).toHaveLength(1)
     expect(f.store.db.prepare('SELECT * FROM changed_rows').all()).toEqual([])
-    expect(f.store.messagePage(owner, profile, sessionID, 902, 100)).toBeDefined()
+    expect(f.store.sourceMessagePage(owner, profile, sessionID, 902, 100)).toBeDefined()
     coordinator.observe(owner, profile, sessionID, { type: 'message.complete', seq: 1 })
     expect(request).toHaveBeenCalledTimes(2)
     f.store.close()
@@ -663,7 +663,7 @@ describe('local history and bounded tail synchronization', () => {
     const { coordinator, request } = upstreamFor(f, rows)
     await coordinator.reconcile(owner, profile, sessionID)
     expect(request.mock.calls.filter(([path]) => path.endsWith('/messages'))).toHaveLength(2)
-    expect(JSON.parse(f.store.messagePage(owner, profile, sessionID, 0, 10)!.response.body.toString()).pagination.total).toBe(1130)
+    expect(JSON.parse(f.store.sourceMessagePage(owner, profile, sessionID, 0, 10)!.response.body.toString()).pagination.total).toBe(1130)
     f.store.close()
   })
 
@@ -672,11 +672,11 @@ describe('local history and bounded tail synchronization', () => {
     const rows = f.rows.slice(1).map(row => row.id === 'row-2' ? { ...row, content: 'edited old message' } : row)
     const { coordinator, request } = upstreamFor(f, rows)
     await expect(coordinator.reconcile(owner, profile, sessionID)).rejects.toThrow('explicit refresh')
-    expect(JSON.parse(f.store.messagePage(owner, profile, sessionID, 900, 100)!.response.body.toString()).messages[0].id).toBe('row-0')
+    expect(JSON.parse(f.store.sourceMessagePage(owner, profile, sessionID, 900, 100)!.response.body.toString()).messages[0].id).toBe('row-0')
     request.mockClear()
     await coordinator.reconcile(owner, profile, sessionID, true)
     expect(request.mock.calls.filter(([path]) => path.endsWith('/messages'))).toHaveLength(10)
-    const page = JSON.parse(f.store.messagePage(owner, profile, sessionID, 899, 100)!.response.body.toString())
+    const page = JSON.parse(f.store.sourceMessagePage(owner, profile, sessionID, 899, 100)!.response.body.toString())
     expect(page.messages[0].id).toBe('row-1')
     expect(page.messages[1].content).toBe('edited old message')
     expect(page.pagination.total).toBe(999)
@@ -687,8 +687,8 @@ describe('local history and bounded tail synchronization', () => {
     const f = fixture()
     f.store.recordRoute(owner, profile, sessionID, 'runtime')
     f.store.putSnapshot(owner, 'tail', 'messages', profile, sessionID, response({ messages: [{ id: 'last', role: 'assistant', content: 'tail' }], pagination: { total: 400, offset: 0, has_more: true } }))
-    expect(f.store.messagePage(owner, profile, sessionID, 0, 1)).toBeDefined()
-    expect(f.store.messagePage(owner, profile, sessionID, 1, 100)).toBeUndefined()
+    expect(f.store.sourceMessagePage(owner, profile, sessionID, 0, 1)).toBeDefined()
+    expect(f.store.sourceMessagePage(owner, profile, sessionID, 1, 100)).toBeUndefined()
     f.store.close()
   })
 
@@ -701,7 +701,7 @@ describe('local history and bounded tail synchronization', () => {
       return response({ messages: f.rows.slice(-100), pagination: { total: 1000, offset: 0, has_more: true } })
     } } as unknown as UpstreamServiceSession)
     await expect(coordinator.reconcile(owner, profile, sessionID, true)).rejects.toThrow('offline')
-    expect(f.store.messagePage(owner, profile, sessionID, 900, 100)).toBeDefined()
+    expect(f.store.sourceMessagePage(owner, profile, sessionID, 900, 100)).toBeDefined()
     f.store.close()
   })
 
@@ -732,7 +732,7 @@ describe('local history and bounded tail synchronization', () => {
       return original(path, options)
     })
     const published = vi.fn(() => {
-      const stored = JSON.parse(f.store.messagePage(owner, profile, sessionID, 0, 1)!.response.body.toString())
+      const stored = JSON.parse(f.store.sourceMessagePage(owner, profile, sessionID, 0, 1)!.response.body.toString())
       expect(stored.messages[0].id).toBe('newest')
     })
     coordinator.onSynchronized = published

+ 4 - 4
tests/server/chatCachePagination.test.ts

@@ -32,7 +32,7 @@ describe('Hermes pagination without total and has_more', () => {
   it.each([250, 300])('force refresh preserves all %i messages and correct page positions', async count => {
     const f = fixture(count)
     await f.coordinator.reconcile('owner', 'default', 'chat', true)
-    const page = f.store.messagePage('owner', 'default', 'chat', count - 100, 100)!
+    const page = f.store.sourceMessagePage('owner', 'default', 'chat', count - 100, 100)!
     const payload = JSON.parse(page.response.body.toString())
     expect(payload.pagination.total).toBe(count)
     expect(payload.messages[0].id).toBe('0')
@@ -45,9 +45,9 @@ describe('Hermes pagination without total and has_more', () => {
     const f = fixture(250)
     f.store.putSnapshot('owner', 'detail', 'detail', 'default', 'chat', response({ id: 'chat', message_count: 250, title: 'History' }))
     f.store.putSnapshot('owner', 'tail', 'messages', 'default', 'chat', response({ session_id: 'chat', messages: f.rows.slice(-100), pagination: { offset: 0, limit: 100, returned: 100 } }))
-    const payload = JSON.parse(f.store.messagePage('owner', 'default', 'chat', 0, 100)!.response.body.toString())
+    const payload = JSON.parse(f.store.sourceMessagePage('owner', 'default', 'chat', 0, 100)!.response.body.toString())
     expect(payload.pagination).toMatchObject({ total: 250, has_more: true })
-    expect(f.store.messagePage('owner', 'default', 'chat', 100, 100)).toBeUndefined()
+    expect(f.store.sourceMessagePage('owner', 'default', 'chat', 100, 100)).toBeUndefined()
     f.store.close()
   })
 
@@ -56,7 +56,7 @@ describe('Hermes pagination without total and has_more', () => {
     f.store.putSnapshot('owner', 'seed', 'messages', 'default', 'chat', response({ session: { id: 'chat', message_count: 250 }, messages: f.rows.slice(0, 250), pagination: { total: 250, offset: 0, has_more: false } }))
     await f.coordinator.reconcile('owner', 'default', 'chat')
     expect(f.request.mock.calls.filter(([path]) => path.endsWith('/messages'))).toHaveLength(1)
-    const page = JSON.parse(f.store.messagePage('owner', 'default', 'chat', 0, 100)!.response.body.toString())
+    const page = JSON.parse(f.store.sourceMessagePage('owner', 'default', 'chat', 0, 100)!.response.body.toString())
     expect(page.pagination.total).toBe(252)
     expect(page.messages.at(-1).id).toBe('251')
     f.store.close()

+ 1 - 1
tests/server/chatCacheRoutes.test.ts

@@ -183,7 +183,7 @@ describe('source=web chat cache routes', () => {
     expect(ownedMessages.body).toMatchObject({
       owned: true,
       session: { id: 'owned-session', source: 'ios', owned: true },
-      messages: [{ id: 'owned-message' }],
+      messages: [{ source_message_id: 'owned-message' }],
     })
 
     const searched = await agent.get('/api/app/sessions/search?q=Hermes&profile=default')

+ 7 - 4
tests/server/chatMessageIdentity.test.ts

@@ -35,12 +35,14 @@ function submit(store: ChatCacheStore, client = 'local', at = now, options: Row
 }
 function row(id = '1155', at = now + 39): Row { return { id, role: 'user', content: text, timestamp: at / 1000 } }
 function sync(store: ChatCacheStore, messages: Row[], force = false) {
+  // History repair is admitted only after the execution route is idle.
+  store.recordEvent(...scope,{type:'route.resumed',payload:{running:false}})
   return store.applySync(...scope, store.revision(...scope), [{
     key: 'messages', kind: 'messages', response: response(messages), startedAt: now + 2000,
   }], force)
 }
 function read(store: ChatCacheStore, offset = 0, limit = 100): Row[] {
-  return JSON.parse(store.messagePage(...scope, offset, limit)!.response.body.toString()).messages
+  return JSON.parse(store.sourceMessagePage(...scope, offset, limit)!.response.body.toString()).messages
 }
 afterEach(() => {
   vi.restoreAllMocks()
@@ -110,9 +112,9 @@ describe('ordinary chat submission identities', () => {
   it('keeps an unconfirmed send when an older identical user message occupies its position', () => {
     const { store } = fixture()
     submit(store, 'pending', now, {}, 'pending')
-    expect(() => sync(store, [row('old', now - 60_000)]))
-      .toThrow('Unconfirmed submission must be reconciled')
-    expect(read(store)[0]).toMatchObject({ id: 'user:web:prompt:pending', status: 'pending' })
+    expect(sync(store, [row('old', now - 60_000)])).toBe(true)
+    expect(store.transcripts.all(...scope)).toContainEqual(expect.objectContaining({client_message_id:'pending',status:'pending'}))
+    expect(read(store)[0]).toMatchObject({id:'old'})
   })
 
   it('uses an explicit upstream identity for queued messages without timestamp heuristics', () => {
@@ -133,6 +135,7 @@ describe('ordinary chat submission identities', () => {
   it('does not bind the first page of an ambiguous multi-page refresh', () => {
     const { store } = fixture()
     submit(store)
+    store.recordEvent(...scope,{type:'route.resumed',payload:{running:false}})
     store.applySync(...scope, store.revision(...scope), [
       { key: 'tail', kind: 'messages', response: response([row('2', now + 40)], 0, 2), startedAt: now + 2000 },
       { key: 'older', kind: 'messages', response: response([row('1')], 1, 2), startedAt: now + 2000 },

+ 2 - 2
tests/server/chatTranscript.test.ts

@@ -55,7 +55,7 @@ describe('ordinary server-owned transcript',()=>{
     expect(events).toHaveLength(1);expect(events[0]!.type).toBe('message.patch')
     const replay=events.reduce(applyTranscriptEvent,base.messages)
     expect(replay).toEqual(snapshot(store).messages)
-    expect(replay[0]).toMatchObject({id,content:'中文🙂',revision:2})
+    expect(replay[0]).toMatchObject({id,content:'中文🙂',revision:base.messages[0]!.revision+1})
     expect(applyTranscriptEvent(replay,events[0]!)).toEqual(replay)
   })
   it('retains stable message identity when an upstream row ID becomes known',()=>{
@@ -84,7 +84,7 @@ describe('ordinary server-owned transcript',()=>{
     cache.observe('owner','p','s',{type:'message.complete',payload:{text:'结束'},delivery_id:'two'})
     const after=snapshot(store);cache.close();store.close()
     const reopened=new ChatCacheStore(home)
-    try{expect(reopened.transcripts.epoch).toBe(before.epoch);expect(reopened.transcripts.events('owner','p','s',before.cursor).reduce(applyTranscriptEvent,before.messages)).toEqual(after.messages)}finally{reopened.close()}
+    try{expect(reopened.transcripts.epochFor('owner','p','s')).toBe(before.epoch);expect(reopened.transcripts.events('owner','p','s',before.cursor).reduce(applyTranscriptEvent,before.messages)).toEqual(after.messages)}finally{reopened.close()}
   })
   it('keeps owner/session scopes and history pagination independent',()=>{
     const {store,cache}=fixture()

+ 36 - 1
tests/server/desktopSync.test.ts

@@ -14,7 +14,7 @@ const homes: string[] = []
 afterEach(() => { for (const home of homes.splice(0)) rmSync(home, { recursive: true, force: true }) })
 const temporary = () => { const home = realpathSync(mkdtempSync(join(tmpdir(), 'yaoyao-sync-unit-'))); homes.push(home); return home }
 function runtime(root: string, commit = 'b'.repeat(40), version = '0.3.32', ancestors = ['a'.repeat(40)]) {
-  mkdirSync(join(root, 'bin'), { recursive: true }); mkdirSync(join(root, 'ui'))
+  mkdirSync(join(root, 'bin'), { recursive: true }); mkdirSync(join(root, 'ui'), { recursive: true })
   for (const file of ['node', 'server.mjs', 'ui/index.html', 'bin/hermes-yaoyao.mjs', 'bin/hermes-yaoyao-updater.mjs']) writeFileSync(join(root, file), file)
   writeJSON(join(root, 'release.json'), { schemaVersion: 1, releaseVersion: version, webVersion: version, gitTag: `v${version}` })
   writeJSON(join(root, 'build-info.json'), { commit, ancestors, buildNumber: ancestors.length + 1, dirty: false })
@@ -140,6 +140,41 @@ describe('transactional service switching', () => {
     expect(f.counts()).toEqual({ stops: 0, starts: 0 })
     expect(existsSync(join(f.home, 'updates', 'desktop-sync.json'))).toBe(false)
   })
+  it('explicitly overwrites an unrelated same-version build, preserving data and bypassing an old sync receipt', async () => {
+    const f=fixture()
+    runtime(f.old,'c'.repeat(40),'0.3.32',[])
+    await expect(synchronizeDesktop({...f,runtimeRoot:f.target})).rejects.toMatchObject({code:'service_build_unknown'})
+    expect(f.counts()).toEqual({stops:0,starts:0})
+    const target=verifyRuntimePackage(f.target)
+    writeJSON(join(f.home,'updates','desktop-sync.json'),{artifactDigest:target.artifactDigest,action:'newer'})
+    const result=await synchronizeDesktop({...f,runtimeRoot:f.target,force:true})
+    expect(result.action).toBe('overwrite');expect(result.current.artifactDigest).toBe(target.artifactDigest)
+    expect(f.counts()).toEqual({stops:1,starts:1})
+    expect(readFileSync(join(f.home,'settings.json'),'utf8')).toBe('original')
+    const database=new DatabaseSync(join(f.home,'workspace.sqlite3'),{readOnly:true})
+    expect(database.prepare('SELECT value FROM messages').get()?.value).toBe('before');database.close()
+    expect(existsSync(JSON.parse(readFileSync(join(f.home,'updates','last-success.json'),'utf8')).snapshot)).toBe(true)
+    expect((await synchronizeDesktop({...f,runtimeRoot:f.target})).action).toBe('already-synced')
+    expect(f.counts()).toEqual({stops:1,starts:1})
+  })
+  it('does not use force to cross versions, bypass idle checks or accept a damaged package', async () => {
+    const f=fixture()
+    await expect(synchronizeDesktop({...f,runtimeRoot:f.target,force:true})).rejects.toMatchObject({code:'service_force_version_mismatch'})
+    runtime(f.old,'c'.repeat(40),'0.3.32',[])
+    f.driver.quiesce=async()=>{throw new Error('busy')}
+    await expect(synchronizeDesktop({...f,runtimeRoot:f.target,force:true})).rejects.toThrow('busy')
+    expect(f.counts()).toEqual({stops:0,starts:0})
+    writeFileSync(join(f.target,'server.mjs'),'broken')
+    await expect(synchronizeDesktop({...f,runtimeRoot:f.target,force:true})).rejects.toThrow('校验失败')
+    expect(f.counts()).toEqual({stops:0,starts:0})
+  })
+  it('restores the previous same-version build and its data when a forced replacement fails', async () => {
+    const f=fixture();runtime(f.old,'c'.repeat(40),'0.3.32',[]);f.fail()
+    await expect(synchronizeDesktop({...f,runtimeRoot:f.target,force:true})).rejects.toThrow('wrong running build')
+    expect(currentRelease(f.releaseRoot)).toBe(f.old)
+    expect(readFileSync(join(f.home,'settings.json'),'utf8')).toBe('original')
+    expect(existsSync(join(f.home,'updates','desktop-sync.json'))).toBe(false)
+  })
   it('synchronizes an App build once, allowing Web to move independently afterwards', async () => {
     const f = fixture()
     await synchronizeDesktop({ ...f, runtimeRoot: f.target })

+ 2 - 1
tests/server/ordinaryChatLocal.test.ts

@@ -92,7 +92,8 @@ describe('ordinary chat migration and bounded recovery',()=>{
  it('promotes an assistant identity without creating a second history row',()=>{
    const {store,coordinator}=setup();store.recordCommand('o','p','s','session.create',{})
    coordinator.observe('o','p','s',{type:'message.delta',payload:{text:'hello'},delivery_id:'delta'})
+   const stableID=store.transcripts.all('o','p','s')[0]!.id
    coordinator.observe('o','p','s',{type:'message.complete',payload:{message_id:'canonical',text:'hello'},delivery_id:'done'})
-   const page=json(coordinator.readLocal('o','messages','p','s',{}));expect(page.messages).toHaveLength(1);expect(page.messages[0].id).toBe('canonical')
+   const page=json(coordinator.readLocal('o','messages','p','s',{}));expect(page.messages).toHaveLength(1);expect(page.messages[0]).toMatchObject({id:stableID,source_message_id:'canonical'})
  })
 })

+ 149 - 0
tests/server/ordinaryTranscriptApi.test.ts

@@ -0,0 +1,149 @@
+// @vitest-environment node
+import { createServer, type Server } from 'node:http'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import request from 'supertest'
+import { afterEach, describe, expect, it } from 'vitest'
+import { createApplication, type ApplicationRuntime } from '../../src/server/app'
+import type { ServerConfig } from '../../src/server/config'
+import { SSEParser } from '../../src/shared/sse'
+import {
+  applyTranscriptEvent,
+  CHAT_TRANSCRIPT_FEATURE,
+  type TranscriptEvent,
+  type TranscriptMessage,
+} from '../../src/shared/chatTranscript'
+const fixtures: Array<{ home: string; runtime: ApplicationRuntime; server: Server }> = []
+afterEach(async () => {
+  for (const f of fixtures.splice(0)) {
+    f.runtime.close()
+    f.server.closeAllConnections()
+    await new Promise<void>((resolve) => f.server.close(() => resolve()))
+    rmSync(f.home, { recursive: true, force: true })
+  }
+})
+describe('ordinary v2 HTTP snapshot and durable SSE integration', () => {
+  it('replays the exact committed snapshot and rejects a legacy ordinary channel', async () => {
+    const home = mkdtempSync(join(tmpdir(), 'ordinary-v2-api-'))
+    const server = createServer()
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
+    const port = (server.address() as { port: number }).port
+    const config: ServerConfig = {
+      host: '127.0.0.1',
+      port,
+      upstream: new URL('http://127.0.0.1:9119'),
+      allowedHosts: new Set(),
+      home,
+      mediaRoot: home,
+      attachmentsRoot: home,
+      imagesRoot: home,
+      mediaOwner: 'test',
+      allowInsecureLan: false,
+      insecureLan: false,
+      production: false,
+    }
+    const runtime = createApplication({
+      config,
+      fetchImpl: async (input) => {
+        const path = new URL(String(input)).pathname
+        return path === '/api/status'
+          ? Response.json({ auth_required: false })
+          : path === '/'
+            ? new Response(
+                '<script>window.__HERMES_SESSION_TOKEN__="fixture-token-1234567890123456";</script>',
+              )
+            : path === '/api/profiles'
+              ? Response.json({ profiles: [{ name: 'default', is_default: true }] })
+              : Response.json({})
+      },
+    })
+    server.on('request', runtime.app.callback())
+    fixtures.push({ home, runtime, server })
+    const host = `127.0.0.1:${port}`,
+      agent = request.agent(server)
+    const bootstrap = await agent.get('/api/app/bootstrap').set('Host', host).expect(200)
+    const setup = await agent
+      .post('/api/app/setup')
+      .set('Host', host)
+      .set('Origin', `http://${host}`)
+      .set('X-CSRF-Token', bootstrap.body.csrfToken)
+      .send({ username: 'owner', password: 'fixture-password' })
+      .expect(200)
+    const owner = String(setup.body.user.id),
+      store = runtime.chatCache.store
+    const capabilities = await agent.get('/api/realtime/capabilities').set('Host', host).expect(200)
+    expect(capabilities.body.features).toContain(CHAT_TRANSCRIPT_FEATURE)
+    await agent
+      .post('/api/realtime/channels')
+      .set('Host', host)
+      .set('Origin', `http://${host}`)
+      .set('X-CSRF-Token', capabilities.body.csrfToken)
+      .send({ channel: 'chat' })
+      .expect(426)
+    store.recordCommand(owner, 'default', 's', 'session.create', { source: 'web' })
+    const base = (
+      await agent.get('/api/app/chat/sessions/s/snapshot?profile=default').set('Host', host).expect(200)
+    ).body
+    const cookies = new Map<string, string>()
+    for (const response of [bootstrap, setup, capabilities])
+      for (const value of (response.headers['set-cookie'] ?? []) as unknown as string[]) {
+        const pair = value.split(';')[0]!
+        cookies.set(pair.split('=')[0]!, pair)
+      }
+    const controller = new AbortController()
+    const stream = await fetch(`http://127.0.0.1:${port}/api/app/chat/sessions/s/events?profile=default`, {
+      headers: {
+        Host: host,
+        Cookie: [...cookies.values()].join('; '),
+        'Last-Event-ID': `${base.epoch}:${base.cursor}`,
+      },
+      signal: controller.signal,
+    })
+    expect(stream.status).toBe(200)
+    const reader = stream.body!.getReader(),
+      parser = new SSEParser(),
+      decoder = new TextDecoder()
+    let seq = 0
+    for (const [type, payload] of [
+      ['message.start', {}],
+      ['message.delta', { text: '完成' }],
+      ['message.interim', { text: '完成', already_streamed: true }],
+      ['message.complete', { text: '完成', response_previewed: true }],
+    ] as Array<[string, object]>)
+      runtime.realtime.broker.onNativeEvent(owner, 'default', 's', {
+        type,
+        payload,
+        session_id: 'runtime',
+        seq: ++seq,
+        epoch: 'native-epoch',
+        delivery_id: `native:${seq}`,
+      })
+    const final = (
+      await agent.get('/api/app/chat/sessions/s/snapshot?profile=default').set('Host', host).expect(200)
+    ).body
+    let rows: TranscriptMessage[] = base.messages,
+      cursor = base.cursor
+    try {
+      while (cursor < final.cursor) {
+        const chunk = await reader.read()
+        expect(chunk.done).toBe(false)
+        for (const frame of parser.feed(decoder.decode(chunk.value, { stream: true }))) {
+          if (frame.event !== 'transcript') continue
+          const event = JSON.parse(frame.data) as TranscriptEvent
+          expect(event.epoch).toBe(base.epoch)
+          expect(event.previousCursor).toBe(cursor)
+          rows = applyTranscriptEvent(rows, event)
+          cursor = event.cursor
+        }
+      }
+    } finally {
+      controller.abort()
+      await reader.cancel().catch(() => {})
+    }
+    expect(rows).toEqual(final.messages)
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({ content: '完成', status: 'complete', final_result: true })
+    expect(store.db.prepare('SELECT COUNT(*) n FROM chat_messages').get()!.n).toBe(0)
+  })
+})

+ 246 - 0
tests/server/ordinaryTranscriptV2.test.ts

@@ -0,0 +1,246 @@
+// @vitest-environment node
+import { afterEach, describe, expect, it } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { ChatCacheStore } from '../../src/server/chatCache'
+import { applyTranscriptEvent } from '../../src/shared/chatTranscript'
+import fixture from '../fixtures/ordinary-chat-v2/protocol.json'
+const scope = ['owner', 'p', 's'] as const
+const stores: Array<{ home: string; store: ChatCacheStore }> = []
+function setup() {
+  const home = mkdtempSync(join(tmpdir(), 'ordinary-v2-')),
+    store = new ChatCacheStore(home)
+  stores.push({ home, store })
+  store.recordCommand(...scope, 'session.create', { source: 'web' })
+  let seq = 0
+  return {
+    store,
+    send: (type: string, payload: object = {}, id?: string) =>
+      store.recordEvent(...scope, { type, payload, delivery_id: id ?? String(++seq) }),
+  }
+}
+afterEach(() => {
+  for (const f of stores.splice(0)) {
+    if (!f.store.isClosed) f.store.close()
+    rmSync(f.home, { recursive: true, force: true })
+  }
+})
+const messages = (store: ChatCacheStore) => store.transcripts.all(...scope)
+describe('ordinary v2 canonical writer', () => {
+  it('updates a final preview in place and never writes another live representation', () => {
+    const { store, send } = setup()
+    send('message.start')
+    send('message.delta', { text: '已经完成。' })
+    const id = messages(store)[0]!.id
+    for (let i = 0; i < 3; i++) send('message.interim', { text: '已经完成。', already_streamed: true })
+    send('message.complete', { text: '已经完成。', response_previewed: true })
+    send('run.completed', { text: '已经完成。' })
+    expect(messages(store)).toHaveLength(1)
+    expect(messages(store)[0]).toMatchObject({
+      id,
+      content: '已经完成。',
+      status: 'complete',
+      final_result: true,
+    })
+    expect(store.db.prepare('SELECT COUNT(*) n FROM chat_messages').get()!.n).toBe(0)
+  })
+  it('restores an active turn through a snapshot then promotes its upstream ID', () => {
+    const { store, send } = setup()
+    send('route.resumed', { running: true, inflight: { assistant: '前半段' } })
+    const id = messages(store)[0]!.id
+    send('message.delta', { message_id: 'upstream-event', text: '后半段' })
+    send('message.complete', { message_id: 'persisted-42', text: '前半段后半段' })
+    expect(messages(store)).toHaveLength(1)
+    expect(messages(store)[0]).toMatchObject({
+      id,
+      source_message_id: 'persisted-42',
+      content: '前半段后半段',
+    })
+  })
+  it('preserves two identical actual sends and their queued turns across restart', () => {
+    const { store, send } = setup()
+    store.recordCommand(...scope, 'prompt.submit', { text: '相同问题', _delivery_id: 'web:prompt:one' })
+    send('command.confirmed', { delivery_id: 'web:prompt:one' })
+    send('message.start')
+    send('message.delta', { text: '相同回复' })
+    store.recordCommand(...scope, 'prompt.submit', {
+      text: '相同问题',
+      _delivery_id: 'web:prompt:two',
+      queued: true,
+    })
+    send('command.confirmed', { delivery_id: 'web:prompt:two', status: 'queued' })
+    send('message.complete', { text: '相同回复', queue_remaining: 1 })
+    send('message.start')
+    send('message.delta', { text: '相同回复' })
+    send('message.complete', { text: '相同回复' })
+    const all = messages(store)
+    expect(all.filter((m) => m.role === 'user')).toHaveLength(2)
+    expect(all.filter((m) => m.final_result)).toHaveLength(2)
+    expect(new Set(all.filter((m) => m.role === 'assistant').map((m) => m.turn_id)).size).toBe(2)
+    const { home } = stores.at(-1)!
+    store.close()
+    const reopened = new ChatCacheStore(home)
+    try {
+      expect(messages(reopened)).toEqual(all)
+    } finally {
+      reopened.close()
+    }
+  })
+  it('keeps steer in the current turn without moving the reply behind a future user', () => {
+    const { store, send } = setup()
+    store.recordCommand(...scope, 'prompt.submit', { text: '开始', _delivery_id: 'web:prompt:one' })
+    send('message.delta', { text: '前' })
+    const assistant = messages(store).find((m) => m.role === 'assistant')!
+    store.recordCommand(...scope, 'session.steer', { text: '补充', _delivery_id: 'web:prompt:steer' })
+    send('message.delta', { text: '后' })
+    send('message.complete')
+    expect(messages(store).filter((m) => m.role === 'assistant')).toMatchObject([
+      { id: assistant.id, content: '前后' },
+    ])
+    expect(new Set(messages(store).map((m) => m.turn_id)).size).toBe(1)
+  })
+  it('keeps a delayed tool result attached to its original segment', () => {
+    const { store, send } = setup()
+    send('message.interim', { text: '开始检查' })
+    send('tool.start', { tool_id: 't', name: 'terminal' })
+    send('message.interim', { text: '过程说明' })
+    send('message.delta', { text: '完成' })
+    send('tool.complete', { tool_id: 't', result: 'ok' })
+    send('message.complete', { text: '完成' })
+    expect(messages(store).map((m) => m.content)).toEqual(['开始检查', '过程说明', '完成'])
+    expect(messages(store).flatMap((m) => (m.tool_calls ?? []) as object[])).toMatchObject([
+      { id: 't', result: 'ok' },
+    ])
+  })
+  it('deduplicates persisted source receipts after a restart', () => {
+    const { store } = setup(),
+      frame = {
+        type: 'message.delta',
+        session_id: 'runtime',
+        epoch: 'upstream-epoch',
+        seq: 3,
+        payload: { text: '哈' },
+        delivery_id: 'upstream-epoch:runtime:3',
+      }
+    store.recordEvent(...scope, frame)
+    const before = messages(store)
+    const home = stores.at(-1)!.home
+    store.close()
+    const reopened = new ChatCacheStore(home)
+    try {
+      expect(reopened.recordEvent(...scope, frame)).toBe(false)
+      expect(messages(reopened)).toEqual(before)
+      expect(reopened.transcripts.sourceCursor(...scope, 'runtime', 'upstream-epoch')).toBe(3)
+    } finally {
+      reopened.close()
+    }
+  })
+  it('repairs a verified idle history in a new epoch without duplicating a partial page', () => {
+    const { store, send } = setup()
+    send('message.complete', { text: '最终结果' })
+    const epoch = store.transcripts.epochFor(...scope)
+    const result = store.applySync(
+      ...scope,
+      store.revision(...scope),
+      [
+        {
+          key: 'history',
+          kind: 'messages',
+          startedAt: Date.now(),
+          response: {
+            status: 200,
+            headers: new Headers(),
+            body: Buffer.from(
+              JSON.stringify({
+                messages: [{ id: 'server-final', role: 'assistant', content: '最终结果' }],
+                pagination: { offset: 0, total: 1 },
+              }),
+            ),
+          },
+        },
+      ],
+      true,
+    )
+    expect(result).toBe(true)
+    expect(messages(store)).toHaveLength(1)
+    expect(messages(store)[0]!.content).toBe('最终结果')
+    expect(store.transcripts.epochFor(...scope)).not.toBe(epoch)
+    expect(store.db.prepare('SELECT COUNT(*) n FROM chat_transcript_archives').get()!.n).toBeGreaterThan(0)
+  })
+  it('does not replace an active turn or its pending input while history is fetched', () => {
+    const { store, send } = setup()
+    store.recordCommand(...scope, 'prompt.submit', { text: '保留', _delivery_id: 'web:prompt:one' })
+    send('message.delta', { text: '正在回复' })
+    const before = messages(store)
+    expect(store.applySync(...scope, store.revision(...scope), [], true)).toBe(false)
+    expect(messages(store)).toEqual(before)
+  })
+  it('matches the shared protocol fixture including duplicate delivery', () => {
+    let rows = fixture.snapshot.messages as any
+    for (const event of fixture.events) rows = applyTranscriptEvent(rows, event as any)
+    expect(rows).toEqual(fixture.expectedMessages)
+  })
+  it('does not append ambiguous replay bytes after an upstream reset snapshot', () => {
+    const { store, send } = setup()
+    send('message.delta', { text: '前' })
+    const id = messages(store)[0]!.id
+    send('gateway.reset', { reason: 'upstream_replay_unavailable' })
+    send('route.resumed', { running: true, inflight: { assistant: '前后' } })
+    send('message.delta', { text: '后' })
+    expect(messages(store)[0]).toMatchObject({ id, content: '前后' })
+    send('message.complete', { text: '前后完整结果' })
+    expect(messages(store)).toHaveLength(1)
+    expect(messages(store)[0]).toMatchObject({ id, content: '前后完整结果' })
+  })
+  it('does not allow another viewer resume to overwrite a newer live stream', () => {
+    const { store, send } = setup()
+    send('message.delta', { text: '较新的正文' })
+    send('route.resumed', { running: true, inflight: { assistant: '旧快照' } })
+    expect(messages(store).map((m) => m.content)).toEqual(['较新的正文'])
+  })
+  it('routes a late terminal snapshot to its identified old turn', () => {
+    const { store, send } = setup()
+    send('message.complete', { message_id: 'first', text: '第一轮' })
+    store.recordCommand(...scope, 'prompt.submit', { text: '下一轮', _delivery_id: 'web:prompt:two' })
+    send('message.delta', { message_id: 'second', text: '正在继续' })
+    const current = store.transcripts.head(...scope).current
+    send('message.complete', { message_id: 'first', text: '第一轮' })
+    expect(store.transcripts.head(...scope)).toMatchObject({ current, running: true })
+    expect(
+      messages(store)
+        .filter((m) => m.role === 'assistant')
+        .map((m) => m.content),
+    ).toEqual(['第一轮', '正在继续'])
+  })
+  it('keeps structured final attachments and error state in the canonical snapshot', () => {
+    const { store, send } = setup()
+    send('message.complete', { content: [{ type: 'file', path: '/result.pdf', name: '结果.pdf' }] })
+    expect(messages(store)[0]!.content).toEqual([{ type: 'file', path: '/result.pdf', name: '结果.pdf' }])
+    send('message.start')
+    send('run.failed', { error: '工具执行失败' })
+    expect(store.transcripts.snapshot(...scope, {}, 'current')).toMatchObject({
+      running: false,
+      error: '工具执行失败',
+    })
+  })
+  it('does not resurrect a finished turn when a queued command is rejected late', () => {
+    const { store, send } = setup()
+    store.recordCommand(...scope, 'prompt.submit', { text: '第一问', _delivery_id: 'web:prompt:first' })
+    send('message.delta', { text: '第一轮回复' })
+    store.recordCommand(...scope, 'prompt.submit', { text: '排队', _delivery_id: 'web:prompt:queued' })
+    send('message.complete', { text: '第一轮回复' })
+    send('command.rejected', { delivery_id: 'web:prompt:queued', error: '未加入队列' })
+    expect(store.transcripts.head(...scope)).toMatchObject({ running: false, queued: false })
+    expect(messages(store).find((m) => m.client_message_id === 'queued')?.status).toBe('failed')
+  })
+  it('clears obsolete execution queues on an authoritative idle resume without deleting inputs', () => {
+    const { store, send } = setup()
+    store.recordCommand(...scope, 'prompt.submit', { text: '第一问', _delivery_id: 'web:prompt:first' })
+    send('message.delta', { text: '部分回复' })
+    store.recordCommand(...scope, 'prompt.submit', { text: '下一问', _delivery_id: 'web:prompt:queued' })
+    send('route.resumed', { running: false, queued: null })
+    expect(store.transcripts.head(...scope)).toMatchObject({ running: false, queued: false, queue: [] })
+    expect(messages(store).filter((m) => m.role === 'user')).toHaveLength(2)
+  })
+})

+ 153 - 0
tests/server/profileComputer.test.ts

@@ -0,0 +1,153 @@
+// @vitest-environment node
+import {expect,it,vi} from 'vitest'
+import {createServer} from 'node:http'
+import {DatabaseSync} from 'node:sqlite'
+import {mkdtemp,rm,writeFile} from 'node:fs/promises'
+import {tmpdir} from 'node:os'
+import {join} from 'node:path'
+import {randomUUID} from 'node:crypto'
+import {WebSocketServer,type WebSocket} from 'ws'
+import {ComputerGateway,ComputerRuntime} from '../../src/runner/worker/gateway'
+import {UpstreamClient} from '../../src/server/upstream'
+import {UpstreamServiceSession} from '../../src/server/localAuth'
+import type {GatewayFrame} from '../../src/server/workspaceGateway'
+
+async function fixture(){
+  const home=await mkdtemp(join(tmpdir(),'yaoyao-profile-computer-')),db=new DatabaseSync(':memory:')
+  const calls:Array<{method:string;params:any}>=[],bindings:any[]=[],frames:GatewayFrame[]=[],gateways:ComputerGateway[]=[]
+  const sessions=new Map<string,{stored:string;running:boolean}>()
+  let socket:WebSocket,interruptStops=true,allowed=true
+  const server=createServer(async(req,res)=>{
+    let body='';for await(const chunk of req)body+=chunk
+    if(req.url?.endsWith('/bind'))bindings.push(JSON.parse(body))
+    res.setHeader('Content-Type','application/json')
+    res.end(JSON.stringify(req.url==='/api/auth/ws-ticket'?{ticket:'test-ticket'}:req.url?.split('?')[0]?.endsWith('/capabilities')?{version:1,ready:true,in_process:true,native_tools:true}:{ok:true,native_tools:true}))
+  })
+  await new Promise<void>(resolve=>server.listen(0,'127.0.0.1',resolve))
+  const url=new URL(`http://127.0.0.1:${(server.address() as {port:number}).port}`)
+  const ws=new WebSocketServer({server})
+  const emit=(type:string,payload:Record<string,unknown>={},runtimeId=[...sessions.keys()].at(-1)!)=>socket.send(JSON.stringify({method:'event',params:{type,session_id:runtimeId,payload}}))
+  ws.on('connection',connected=>{
+    socket=connected;emit('gateway.ready')
+    connected.on('message',raw=>{
+      const request=JSON.parse(String(raw));calls.push(request)
+      let result:any={ok:true}
+      if(['session.create','session.resume'].includes(request.method)){
+        const id=randomUUID(),stored=request.method==='session.resume'?request.params.session_id:randomUUID()
+        sessions.set(id,{stored,running:false})
+        result={session_id:id,stored_session_id:stored,running:false,info:{profile_name:request.params.profile,cwd:home}}
+      }else if(request.method==='session.active_list')result={sessions:[...sessions].map(([id,s])=>({id,status:s.running?'working':'idle'}))}
+      else if(request.method==='session.usage')result={context_used:123,context_max:32000}
+      else if(request.method==='file.attach')result={ref_text:`[host attachment](${home}/input.txt)`}
+      else if(request.method==='prompt.submit')sessions.get(request.params.session_id)!.running=true
+      else if(request.method==='session.interrupt'&&interruptStops){sessions.get(request.params.session_id)!.running=false;emit('message.complete',{status:'interrupted'},request.params.session_id)}
+      connected.send(JSON.stringify({id:request.id,result}))
+    })
+  })
+  const client=new UpstreamClient(url),target={url,client,session:new UpstreamServiceSession(client,()=>undefined)}
+  const runtime=new ComputerRuntime(db,{protocol:1,runnerId:randomUUID(),serverURL:url.href,hermesURL:url.href,token:'test',allowedProfiles:['default'],artifactRoots:[],computers:{runtime:'docker',imageId:'sha256:'+'a'.repeat(64),python:'/must-not-start-worker',hermesSource:home,hermesHome:home,network:'none'}},home)
+  await runtime.ready;runtime.retainDesktops=true
+  const resolver=vi.spyOn(runtime,'resolve').mockRejectedValue(new Error('isolated Worker must not be used'))
+  vi.spyOn(runtime,'resolveWorkspace').mockResolvedValue({type:'resolved',cwd:'/home/cua/workspace',configuredCwd:home})
+  vi.spyOn(runtime.provider,'ensure').mockResolvedValue({id:'vm',containerId:'vm',running:true,workspace:'/home/cua/workspace',isolation:'container'})
+  vi.spyOn(runtime.provider,'inspect').mockResolvedValue({id:'vm',containerId:'vm',running:true,workspace:'/home/cua/workspace',isolation:'container'})
+  vi.spyOn(runtime.provider,'stop').mockResolvedValue();vi.spyOn(runtime.provider,'remove').mockResolvedValue()
+  vi.spyOn(runtime.provider,'capture').mockResolvedValue({data:'image',width:100,height:80,capturedAt:Date.now()})
+  const execute=vi.spyOn(runtime.provider,'execute').mockResolvedValue({stdout:'vm result',stderr:''})
+  const id=randomUUID(),meta={environmentId:id,agentId:id,ownerKey:'owner',profileSession:true,hostAccess:true}
+  const gateway=()=>{
+    const instance=new ComputerGateway(runtime,meta,randomUUID(),async()=>{if(!allowed)throw new Error('revoked')},async()=>({}),target)
+    instance.onEvent=frame=>frames.push(frame);gateways.push(instance);return instance
+  }
+  const post=async(path:string,body:unknown)=>{
+    const binding=bindings.at(-1)
+    const response=await fetch(binding.bridge_url+path,{method:'POST',headers:{Authorization:`Bearer ${binding.token}`,'Content-Type':'application/json'},body:JSON.stringify(body)})
+    return {status:response.status,body:await response.json() as any}
+  }
+  const tool=async(name:string,args:unknown)=>{
+    const catalog=await post('/tools/list',{})
+    const found=catalog.body.tools.find((t:any)=>t.name===name)
+    expect(found,JSON.stringify(catalog)).toBeDefined()
+    return post('/tools/call',{toolId:found.id,arguments:args,callId:randomUUID()})
+  }
+  return {home,runtime,resolver,execute,meta,gateway,calls,frames,bindings,sessions,post,tool,emit,
+    setInterruptStops(value:boolean){interruptStops=value},revoke(){allowed=false},
+    async close(){
+      interruptStops=true;for(const session of sessions.values())session.running=false
+      await Promise.all(gateways.map(g=>g.close().catch(()=>{})))
+      await runtime.controls.close();await runtime.pool.close();db.close();client.close()
+      for(const c of ws.clients)c.terminate()
+      await new Promise<void>(resolve=>ws.close(()=>resolve()))
+      await new Promise<void>(resolve=>{server.close(()=>resolve());server.closeAllConnections()})
+      vi.restoreAllMocks();await rm(home,{recursive:true,force:true})
+    },
+  }
+}
+
+it('uses a native Profile session and bridge for VM tools, preserves rotated history and keeps Worker sessions separate',async()=>{
+  const f=await fixture()
+  try{
+    const g=f.gateway();await g.connect();const opened=await g.rpc('session.create',{profile:'default'})
+    g.installTeamLease('team',[{id:'team_test',name:'team_test',description:'team fixture',inputSchema:{}}],async()=>({proof:'team-result'}))
+    const attached=await g.rpc('file.attach',{session_id:opened.session_id,name:'input.txt',data_url:'data:text/plain;base64,aGk='})
+    expect(attached.ref_text).toContain(f.home)
+    await g.rpc('prompt.submit',{session_id:opened.session_id,text:'Use the Profile and its local VM'})
+    expect(f.resolver).not.toHaveBeenCalled();expect(f.runtime.workers.size).toBe(0)
+    expect(f.calls.find(c=>c.method==='session.create')?.params).toMatchObject({profile:'default',close_on_disconnect:false})
+    expect(f.calls.find(c=>c.method==='prompt.submit')?.params.text).toContain('本机协作模式')
+    expect(f.bindings.at(-1)).toMatchObject({native_tools:true,profile:'default'})
+    const catalog=(await f.post('/tools/list',{})).body.tools.map((t:any)=>t.name)
+    expect(catalog).toEqual(expect.arrayContaining(['computer_shell','computer_copy_file','team_test']))
+    expect(catalog).not.toContain('host_shell')
+    expect((await f.tool('computer_shell',{command:'pwd'})).body.structuredContent).toMatchObject({stdout:'vm result'})
+    expect(f.execute).toHaveBeenCalledWith(expect.objectContaining({cwd:'/home/cua/workspace'}),['/bin/bash','-lc','pwd'],expect.anything())
+    expect((await f.tool('team_test',{})).body.structuredContent).toEqual({proof:'team-result'})
+    await writeFile(join(f.home,'source.bin'),Buffer.from([0,1,255]))
+    await f.tool('computer_copy_file',{from:'host',source:'source.bin',destination:'target.bin'})
+    expect(f.execute.mock.calls.at(-1)?.[2]?.input).toEqual(Buffer.from([0,1,255]))
+    const rotated=randomUUID();f.emit('session.info',{stored_session_id:rotated})
+    await vi.waitFor(()=>expect(f.runtime.session(opened.session_id,f.meta,'default').profileSessionId).toBe(rotated))
+    expect(f.frames.at(-1)?.payload.stored_session_id).toBe(opened.session_id)
+    f.sessions.values().next().value!.running=false;f.emit('message.complete',{text:'Profile finished',status:'complete'})
+    await vi.waitFor(()=>expect(f.frames.at(-1)?.payload.text).toBe('Profile finished'))
+    expect((await f.runtime.controls.status(f.meta)).mode).toBe('idle')
+    expect(await g.rpc('session.usage',{session_id:opened.session_id})).toMatchObject({context_used:123})
+    await g.close()
+    const resumed=f.gateway();await resumed.connect();await resumed.rpc('session.resume',{profile:'default',session_id:opened.session_id})
+    expect(f.calls.findLast(c=>c.method==='session.resume')?.params.session_id).toBe(rotated)
+    expect(()=>f.runtime.session(opened.session_id,{...f.meta,profileSession:false},'default')).toThrow('执行方式已改变')
+  }finally{await f.close()}
+})
+
+it('waits for native termination and VM calls before human takeover, then resumes only after giveback',async()=>{
+  const f=await fixture()
+  try{
+    const g=f.gateway();await g.connect();const session=await g.rpc('session.create',{profile:'default'})
+    await g.rpc('prompt.submit',{session_id:session.session_id,text:'Work'})
+    let finishTool!:()=>void
+    f.execute.mockImplementationOnce(async()=>{await new Promise<void>(done=>{finishTool=done});return {stdout:'finished',stderr:''}})
+    const pending=f.tool('computer_shell',{command:'long command'})
+    await vi.waitFor(()=>expect(finishTool).toBeTypeOf('function'))
+    f.setInterruptStops(false)
+    const controlId=randomUUID();await f.runtime.controls.take(f.meta,'default',controlId,async()=>{})
+    await vi.waitFor(()=>expect(f.calls.some(c=>c.method==='session.interrupt')).toBe(true))
+    expect((await f.runtime.controls.status(f.meta)).mode).toBe('pausing')
+    for(const native of f.sessions.values())native.running=false
+    f.emit('message.complete',{status:'interrupted'})
+    await new Promise(done=>setTimeout(done,150))
+    expect((await f.runtime.controls.status(f.meta)).mode).toBe('pausing')
+    finishTool();await pending
+    await g.takeControl(controlId,()=>{})
+    await vi.waitFor(async()=>expect((await f.runtime.controls.status(f.meta)).mode).toBe('human'))
+    expect(f.frames.some(frame=>frame.type==='message.complete')).toBe(false)
+    expect((await f.tool('computer_shell',{command:'must not execute'})).body.isError).toBe(true)
+    expect(f.calls.filter(c=>c.method==='prompt.submit')).toHaveLength(1)
+    await f.runtime.controls.giveBack(f.meta,controlId,'已完成登录')
+    expect(f.calls.filter(c=>c.method==='prompt.submit')).toHaveLength(2)
+    expect(f.calls.at(-1)?.params.text).toContain('已完成登录')
+    expect((await f.runtime.controls.status(f.meta)).mode).toBe('agent')
+    f.setInterruptStops(true);await g.rpc('session.interrupt',{session_id:session.session_id})
+    expect((await f.runtime.controls.status(f.meta)).mode).toBe('off')
+    await expect(f.post('/tools/list',{})).rejects.toThrow()
+  }finally{await f.close()}
+})

+ 16 - 0
tests/server/runner.test.ts

@@ -76,6 +76,22 @@ it('requires an upgraded Runner before granting mixed host and VM tools',()=>{
  const id=randomUUID()
  expect(()=>hub.target('owner','local',{environmentId:id,agentId:id,ownerKey:'owner',hostAccess:true})).toThrow('不支持同时使用本机和虚拟机')
 })
+it('rejects Profile collaboration on a Runner that does not advertise the execution backend',()=>{
+ const id=randomUUID()
+ expect(()=>hub.target('owner','local',{environmentId:id,agentId:id,ownerKey:'owner',hostAccess:true,profileSession:true})).toThrow('不支持本机协作模式')
+})
+it.each([false,true])('admits Profile collaboration after an actual computer Runner handshake (Compose: %s)',async compose=>{
+ controller.abort();await running
+ config.computers={runtime:'docker',imageId:'sha256:'+'0'.repeat(64),python:'/fixture/python',hermesSource:home,hermesHome:home,...(compose?{managedBy:'compose' as const}:{})}
+ runner=new RunnerAgent(config,home);controller=new AbortController();running=runner.run(controller.signal);void running.catch(()=>{})
+ await vi.waitFor(()=>expect((runner as any).serverEpoch).toBeTruthy())
+ const features=hub.summary(hub.records()[0]!).features
+ expect(features).toContain('profile-computer-v1')
+ expect(features).toEqual(expect.arrayContaining(['host-computer-tools-v1','computer-worker-v1','computer-control-v1']))
+ if(compose)expect(features).toContain('compose-desktops-v1')
+ const agent=store.createAgent('owner',{name:'协作握手',profile:'default',computer:'vm',execution:'computer',vmExecution:'profile'})
+ expect(()=>hub.target('owner','local',{agentId:agent.id,environmentId:agent.id,ownerKey:'owner',hostAccess:true,profileSession:true})).not.toThrow()
+})
 async function machine(path:string,body?:unknown,overrides:Record<string,string>={}){
   return fetch(`${config.serverURL}/api/runner/v1/${config.runnerId}/${path}`,{
     method:body===undefined?'GET':'POST',headers:{Authorization:`Bearer ${config.token}`,'x-runner-instance':runner.instance,'x-runner-protocol':'1','x-runner-epoch':(runner as any).serverEpoch,'Content-Type':'application/json',...overrides},...(body===undefined?{}:{body:JSON.stringify(body)})

+ 26 - 0
tests/server/workspacePanels.test.ts

@@ -128,6 +128,32 @@ it('persists the separate host option, checks the Runner grant and refuses chang
  target.mockClear();nodes.targetForAgent('owner',store.require<any>('owner','agent',agent.id))
  expect(target.mock.calls[0]?.[2]).not.toHaveProperty('hostAccess')
 })
+it('persists the separate Profile execution mode, checks its Runner capability and prevents running or inherited changes',async()=>{
+ const {cloud}=fakeCloud(),agent=store.createAgent('owner',{name:'本机协作',profile:'default',computer:'vm',execution:'computer'})
+ const target=vi.fn(()=>({runner:{id:'fixture'}} as any));nodes.runnerTarget=target
+ const app=new Koa();app.use(async(ctx,next)=>{try{await next()}catch(error:any){ctx.status=error.status??500;ctx.body={error:error.message}}});app.use(bodyParser());app.use(cloud.router().routes())
+ const path=`/api/app/agents/${agent.id}/computer-selection`
+ const changed=await request(app.callback()).put(path).send({computer:'vm',vmExecution:'profile'}).expect(200)
+ expect(changed.body.agent).toMatchObject({computer:'vm',execution:'computer',vmExecution:'profile',allowHostEnvironment:true})
+ expect(target).toHaveBeenCalledWith('owner','local',expect.objectContaining({profileSession:true,hostAccess:true}))
+ store.put('owner','turn','active-profile',{agentId:agent.id,status:'running'})
+ await request(app.callback()).put(path).send({computer:'vm',vmExecution:'worker'}).expect(409)
+ expect(()=>store.updateAgent('owner',agent.id,{vmExecution:'worker'})).toThrow('先停止当前任务')
+ store.remove('owner','turn','active-profile')
+ const member=store.createAgent('owner',{name:'不继承模式',profile:'default',computer:'vm',execution:'computer',vmExecution:'profile'},{createdByAgentId:agent.id,createdFromRunId:'run'})
+ expect(member.vmExecution).toBe('worker');expect(member.allowHostEnvironment).toBe(false)
+ const worker=await request(app.callback()).put(path).send({computer:'vm',vmExecution:'worker'}).expect(200)
+ expect(worker.body.agent).toMatchObject({vmExecution:'worker',allowHostEnvironment:false})
+ await request(app.callback()).put(path).send({computer:'vm',vmExecution:'profile',allowHostEnvironment:false}).expect(400)
+ await request(app.callback()).put(path).send({computer:'vm',vmExecution:'profile'}).expect(200)
+ const legacy=await request(app.callback()).put(path).send({computer:'vm',allowHostEnvironment:false}).expect(200)
+ expect(legacy.body.agent).toMatchObject({vmExecution:'worker',allowHostEnvironment:false})
+ store.updateAgent('owner',agent.id,{vmExecution:'profile'})
+ expect(store.updateAgent('owner',agent.id,{allowHostEnvironment:false})).toMatchObject({vmExecution:'worker',allowHostEnvironment:false})
+ await request(app.callback()).put(path).send({computer:'vm',vmExecution:'profile'}).expect(200)
+ await request(app.callback()).put(path).send({computer:'off'}).expect(200)
+ expect(store.require<any>('owner','agent',agent.id)).toMatchObject({vmExecution:'worker',allowHostEnvironment:false})
+})
 it('allows the host option for cloud and VM only and clears it when selecting another environment',async()=>{
  const {cloud}=fakeCloud(),agent=store.createAgent('owner',{name:'云端本机选项',profile:'default',computer:'cloud'})
  const available=vi.spyOn(cloud,'requireAvailable').mockResolvedValue(),connect=vi.spyOn(cloud,'connect').mockResolvedValue({} as any)

Неке датотеке нису приказане због велике количине промена