@walkhi/code-relax 0.1.0-beta.29 → 0.1.0-beta.30

package/dist/src/service-doctor.mjs

@@ -1,13 +1,16 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import os from 'node:os';
 import { readRecord } from './service-lifecycle.mjs';
 import { inspectSkill } from './skill-install.mjs';
 import { recoveryStatus } from './shared-recovery.mjs';
 
-export async function doctor({ paths, host, service, skillTarget, ensureAutostart }) {
+export async function doctor({ paths, host, service, skillTarget, ensureAutostart, diagnostics = false }) {
   const checks = [];
   let installedVersion;
   let kernelUpdate = null;
+  let desktopRecovery = null;
+  let serviceState = null;
   const add = (id, status, message) => checks.push({ id, status, message });
   const check = async (id, task) => {
     try { await task(); } catch (error) { add(id, 'error', error.message); }
@@ -21,11 +24,11 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
   });
   await check('bridge-runtime', async () => {
     await host.bridgeEnvironment();
-    add('bridge-runtime', 'ok', '桌面服务启动环境已就绪；实际任务操作尚未验证。');
+    add('bridge-runtime', 'ok', '桌面服务启动环境正常。');
   });
   await check('network', async () => {
     const address = await host.lanAddress();
-    if (!address) throw Error('未找到局域网 IPv4；请连接受信任的 Wi-Fi 或有线网络。');
+    if (!address) { add('network', 'warning', '未连接局域网；需要局域网连接时，请接入 Wi-Fi 或有线网络。'); return; }
     add('network', 'ok', `局域网地址：${address}`);
   });
   await check('autostart', async () => {
@@ -34,7 +37,8 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
   });
   await check('service', async () => {
     const state = await service.status();
-    add('service', state.running ? 'ok' : 'warning', state.running
+    serviceState = state;
+    add('service', state.running ? 'ok' : 'error', state.running
       ? `本机服务正常：${state.mode}，端口 ${state.port}，运行版本：${state.version || '未知'}` : '服务未就绪；安装后执行 relax start。');
     if (state.running && installedVersion && state.version !== installedVersion) add('service-version', 'warning', state.version
       ? `已安装版本 ${installedVersion}，但当前运行版本为 ${state.version}；请重新执行安装或重启工作站服务。`
@@ -46,7 +50,7 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
       command: state.managedAppServer.updatePending ? 'relax kernel-restart --confirm' : null };
     if (state.running) add('managed-app-server', state.managedAppServer?.state === 'ready' ? 'ok' : 'error',
       state.managedAppServer?.state === 'ready' ? `Codex 内核已就绪：版本 ${currentVersion || '未知'}。`
-        : state.managedAppServer?.error || 'Codex 内核尚未就绪。');
+        : `${state.managedAppServer?.error || 'Codex 内核尚未就绪。'} 请执行 relax setup 修复；若提示未安装或未登录 Codex，请先完成安装和登录。`);
     if (state.managedAppServer?.updatePending) {
       const versionDetail = currentVersion && selectedVersion && currentVersion === selectedVersion
         ? `内核版本号未变（${currentVersion}），重启后将使用更新后的安装文件`
@@ -55,18 +59,52 @@ export async function doctor({ paths, host, service, skillTarget, ensureAutostar
         `Codex 更新待应用：${versionDetail}；执行 relax kernel-restart --confirm 应用更新。`);
     }
     if (state.managedAppServer?.launcherRestartRequired) add('managed-app-server-launcher', 'warning',
-      '安装文件已经更新，但当前 app-server 仍由旧启动链创建；隐藏控制台等运行时修复尚未生效，请执行 relax setup 或重启 Windows。');
-  });
-  await check('desktop-recovery', async () => {
-    const state = await recoveryStatus(paths.stateRoot);
-    add('desktop-recovery', state.status === 'failed' ? 'warning' : 'ok',
-      `最近 Desktop 接入：${state.message || state.status}${state.error ? `；${state.error}` : ''}`);
+      '工作站更新尚未完全生效，请执行 relax setup。');
   });
+  if (diagnostics) {
+    try { desktopRecovery = await recoveryStatus(paths.stateRoot); }
+    catch (error) { desktopRecovery = { status: 'unknown', error: error.message }; }
+  }
   await check('skill', async () => {
     const state = inspectSkill(skillTarget);
     add('skill', state.managed ? 'ok' : 'warning', state.managed ? '本包管理的 Skill 已安装。'
       : state.installed ? '存在同名自定义 Skill，本包不会覆盖。' : 'Skill 未安装；重新执行 relax setup。');
   });
-  add('firewall', 'warning', '移动端连通性未验证。首次启动请允许记录的 Node 在受信任的专用网络通信；若曾拒绝，可在 Windows 安全中心的防火墙“允许应用通过防火墙”中检查该 Node。不要关闭整个防火墙。');
-  return { ready: !checks.some(item => item.status === 'error'), lanAccess: 'unverified', kernelUpdate, checks };
+  return { ready: !checks.some(item => item.status === 'error'), kernelUpdate, checks, ...(diagnostics ? { desktopRecovery, diagnostics: {
+    collectedAt: new Date().toISOString(), platform: process.platform, arch: process.arch, osRelease: os.release(),
+    nodeVersion: process.version, nodeExecutable: process.execPath, serviceRoot: paths.serviceRoot,
+    servicePid: serviceState?.pid || null, port: serviceState?.port || null, serviceVersion: serviceState?.version || null,
+  } } : {}) };
+}
+
+export function formatDoctorOutput(result, detail = false) {
+  const labels = { installation: '安装文件', 'bridge-runtime': '运行环境', network: '局域网',
+    autostart: '登录自启动', service: '工作站服务', 'managed-app-server': 'Codex 内核',
+    'service-version': '服务版本', 'managed-app-server-update': 'Codex 更新',
+    'managed-app-server-launcher': '工作站更新', skill: 'Codex Skill' };
+  const byId = id => result.checks.find(item => item.id === id);
+  const summary = (id, success) => {
+    const item = byId(id);
+    return `${labels[id]}：${!item ? '未检查（工作站服务尚未启动）' : item.status === 'ok' ? success : '异常，见下方处理方法'}`;
+  };
+  const issues = result.checks.filter(item => item.status !== 'ok');
+  const lines = [result.ready ? '工作站检查通过。' : '工作站检查发现问题。',
+    summary('installation', '完整'), summary('service', '正在运行'), summary('managed-app-server', '已就绪')];
+  if (issues.length) lines.push('', '需要处理或留意：', ...issues.map(item => `- ${labels[item.id] || item.id}：${item.message}`));
+  if (detail) {
+    const info = result.diagnostics || {};
+    lines.unshift('Code Relax 诊断报告（供客服或技术人员排查）', `采集时间：${info.collectedAt || '未知'}`,
+      `系统：${info.platform || process.platform} ${info.arch || process.arch} ${info.osRelease || ''}`,
+      `Node：${info.nodeVersion || process.version}；${info.nodeExecutable || process.execPath}`,
+      `服务目录：${info.serviceRoot || '未知'}`, `服务进程：${info.servicePid || '未运行'}；端口：${info.port || '未知'}`, '');
+    lines.push('', '检查详情：', ...result.checks.filter(item => item.status === 'ok').map(item => `- ${labels[item.id] || item.id}：${item.message}`));
+    const recovery = result.desktopRecovery;
+    if (recovery && !['none', 'unsupported'].includes(recovery.status)) {
+      const status = { failed: '未完成', completed: '已完成', succeeded: '已完成', running: '进行中', unknown: '无法读取' }[recovery.status] || recovery.status;
+      lines.push('', `Desktop 接入排障记录（仅用于排查上次接入，不代表当前服务状态）：上次 Codex Desktop 接入${status}。`);
+      if (recovery.error) lines.push(`记录原因：${recovery.error}`);
+    }
+  }
+  lines.push('', result.ready ? '添加手机：运行 relax pair 生成配对二维码。' : '按上述方法处理后，再运行 relax doctor。');
+  return lines.join('\n');
 }

package/dist/src/service-health.mjs

@@ -1,33 +1,33 @@
-import WebSocket from 'ws';
-
-// Use the same authenticated LAN protocol as mobile clients; never replay requests.
-export function serviceHealth(session) {
-  if (!session) return Promise.resolve(null);
-  return new Promise((resolve, reject) => {
-    const token = new URL(session.accessUrl).searchParams.get('token');
-    const socket = new WebSocket(`ws://127.0.0.1:${session.port}/api/socket`);
-    let done = false;
-    const finish = (error, value = null) => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      socket.terminate();
-      if (error) reject(error); else resolve(value);
-    };
-    const timer = setTimeout(() => finish(new Error('桌面服务健康检查超时。')), 6000);
-    socket.on('open', () => socket.send(JSON.stringify({ type: 'auth', token })));
-    socket.on('message', data => {
-      try {
-        const message = JSON.parse(data.toString());
-        if (message.type === 'ready') {
-          socket.send(JSON.stringify({ type: 'request', id: 1, method: 'GET', path: '/api/health' }));
-        } else if (message.type === 'response' && message.id === 1) {
-          finish(null, message.status === 200 ? message.body : null);
-        }
-      } catch (error) { finish(error); }
-    });
-    socket.on('error', error => finish(error.code === 'ECONNREFUSED' ? null : error));
-    socket.on('close', code => finish(new Error(code === 1008
-      ? '桌面服务健康检查鉴权失败。' : '桌面服务健康检查连接已断开。')));
-  });
-}
+import WebSocket from 'ws';
+
+// Use the same authenticated LAN protocol as mobile clients; never replay requests.
+export function serviceHealth(session) {
+  if (!session) return Promise.resolve(null);
+  return new Promise((resolve, reject) => {
+    const token = new URL(session.accessUrl).searchParams.get('token');
+    const socket = new WebSocket(`ws://127.0.0.1:${session.port}/api/socket`);
+    let done = false;
+    const finish = (error, value = null) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      socket.terminate();
+      if (error) reject(error); else resolve(value);
+    };
+    const timer = setTimeout(() => finish(new Error('桌面服务健康检查超时。')), 6000);
+    socket.on('open', () => socket.send(JSON.stringify({ type: 'auth', token })));
+    socket.on('message', data => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === 'ready') {
+          socket.send(JSON.stringify({ type: 'request', id: 1, method: 'GET', path: '/api/health' }));
+        } else if (message.type === 'response' && message.id === 1) {
+          finish(null, message.status === 200 ? message.body : null);
+        }
+      } catch (error) { finish(error); }
+    });
+    socket.on('error', error => finish(error.code === 'ECONNREFUSED' ? null : error));
+    socket.on('close', code => finish(new Error(code === 1008
+      ? '桌面服务健康检查鉴权失败。' : '桌面服务健康检查连接已断开。')));
+  });
+}

package/dist/src/service-install.mjs

@@ -20,6 +20,9 @@ export function packageRoot(from) {
 export async function installService(source, target, executable, stateRoot, hooks = {}) {
   assertPlainPath(target);
   if (!fs.existsSync(path.join(source, 'dist/bin/codex-remote.mjs'))) throw new Error('缺少发布构建；源码目录请先执行 npm run build。');
+  const build = readRecord(path.join(source, 'dist/build-platform.json'));
+  if (build?.platform !== process.platform || build?.arch !== process.arch)
+    throw new Error('构建产物与本机系统或 CPU 不匹配，请在目标工作站安装依赖并重新构建。');
   if (!fs.existsSync(path.join(source, 'node_modules'))) throw new Error('缺少包依赖，请重新安装完整 npm 包。');
   const parent = path.dirname(target);
   fs.mkdirSync(parent, { recursive: true });
@@ -32,7 +35,7 @@ export async function installService(source, target, executable, stateRoot, hook
     }
     await exec(executable, [path.join(stage, 'dist/bin/codex-remote.mjs'), '--help'], { windowsHide: true });
     await exec(executable, ['-e', 'const r=require("node:module").createRequire(process.argv[1]); r("sharp"); r("qrcode"); r("ws"); r("node-datachannel");', path.join(stage, 'package.json')], { windowsHide: true });
-    writeRecord(path.join(stage, 'installation.json'), { installedAt: new Date().toISOString(), source, nodeExecutable: executable, stateRoot,
+    writeRecord(path.join(stage, 'installation.json'), { installedAt: new Date().toISOString(), source, nodeExecutable: executable, stateRoot,
       version: readRecord(path.join(source, 'package.json')).version });
     const previous = fs.existsSync(target);
     let previousMoved = false, activated = false;
@@ -64,7 +67,7 @@ export async function installService(source, target, executable, stateRoot, hook
   }
 }
 
-export async function uninstallService({ serviceRoot, stateRoot, uploadsRoot, credentialsRoot }, service, beforeRemove = async () => {}) {
+export async function uninstallService({ serviceRoot, stateRoot, uploadsRoot, credentialsRoot }, service, beforeRemove = async () => {}) {
   const target = path.resolve(serviceRoot);
   assertPlainPath(target);
   if (path.basename(target) !== 'service' || path.basename(path.dirname(target)) !== 'CodexRemote') throw new Error('拒绝删除未识别的服务目录。');
@@ -73,11 +76,11 @@ export async function uninstallService({ serviceRoot, stateRoot, uploadsRoot, cr
     const relative = path.relative(target, path.resolve(data));
     if (!relative || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative))) throw new Error('服务目录包含用户数据，拒绝删除。');
   }
-  if (!fs.existsSync(target)) {
-    await service.stop();
-    await beforeRemove();
-    return { removed: false, serviceRoot: target, preserved };
-  }
+  if (!fs.existsSync(target)) {
+    await service.stop();
+    await beforeRemove();
+    return { removed: false, serviceRoot: target, preserved };
+  }
   const pkg = readRecord(path.join(target, 'package.json'));
   const record = readRecord(path.join(target, 'installation.json'));
   if (pkg?.name !== '@walkhi/code-relax' || !record?.installedAt || !record?.nodeExecutable) throw new Error('缺少有效安装记录，未删除服务目录。');

package/dist/src/service-lifecycle.mjs

@@ -71,7 +71,7 @@ export function lifecycle({ stateRoot, host }) {
     url.hostname = address || '127.0.0.1';
     session.accessUrl = url.href;
     writeRecord(sessionPath, session);
-    return { pid: session.pid, port: session.port, transportMode: connection.transportMode,
+    return { pid: session.pid, port: session.port, version: connection.version, transportMode: connection.transportMode,
       execution: connection.execution, managedAppServer: connection.managedAppServer, desktop: connection.desktop,
       desktopRestartRecommended: connection.desktopRestartRecommended === true, accessUrl: session.accessUrl,
       qrPath: path.join(stateRoot, 'connection-qr.png') };

package/dist/src/service-restart.mjs

@@ -1,81 +1,81 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { fileURLToPath } from 'node:url';
-import { setTimeout as delay } from 'node:timers/promises';
-import { startBackground } from './background-process.mjs';
-import { lifecycle, readRecord, writeRecord } from './service-lifecycle.mjs';
-import * as host from './platform/windows/service-host.mjs';
-import { desktopHost } from './platform/windows/desktop-host.mjs';
-
-const script = fileURLToPath(import.meta.url);
-const sameProcess = (expected, actual) => expected && actual && expected.pid === actual.pid &&
-  expected.created === actual.created && expected.executable === actual.executable;
-async function processIdentity(pid) {
-  const current = await desktopHost.process(pid);
-  return current ? { pid: current.pid, created: current.created, executable: current.executable } : null;
-}
-
-export async function requestServiceRestart(stateRoot) {
-  const lock = path.join(stateRoot, 'service-restart.lock');
-  const operationId = randomUUID();
-  const owner = await processIdentity(process.pid);
-  if (!owner) throw new Error('无法确认服务重启请求进程。');
-  const previous = readRecord(lock);
-  if (previous) {
-    const actual = previous.owner?.pid ? await processIdentity(previous.owner.pid) : null;
-    if (sameProcess(previous.owner, actual) || readRecord(lock)?.operationId !== previous.operationId) {
-      throw new Error('工作站服务已在重启中。');
-    }
-    fs.rmSync(lock);
-  }
-  const temporary = `${lock}.${operationId}.tmp`;
-  try {
-    fs.writeFileSync(temporary, JSON.stringify({ operationId, owner, requestedAt: new Date().toISOString() }),
-      { flag: 'wx', mode: 0o600 });
-    // Publish a complete record exclusively; a crash cannot leave a half-written lock.
-    fs.linkSync(temporary, lock);
-  } catch (error) {
-    if (error.code === 'EEXIST') throw new Error('工作站服务已在重启中。');
-    throw error;
-  } finally { fs.rmSync(temporary, { force: true }); }
-  try {
-    const log = path.join(stateRoot, 'service-restart.log');
-    const pid = await startBackground(process.execPath, [script, '--worker', stateRoot, operationId], process.env, [log, log]);
-    const worker = await processIdentity(pid);
-    if (!worker) throw new Error('服务重启进程未启动。');
-    const current = readRecord(lock);
-    if (current?.operationId !== operationId) throw new Error('服务重启实例已失效。');
-    writeRecord(lock, { ...current, owner: worker });
-    return { operationId, status: 'scheduled', message: '工作站服务重启已安排。' };
-  } catch (error) {
-    const current = readRecord(lock);
-    if (current?.operationId === operationId && sameProcess(current.owner, owner)) fs.rmSync(lock, { force: true });
-    throw error;
-  }
-}
-
-async function run(stateRoot, operationId) {
-  const lock = path.join(stateRoot, 'service-restart.lock');
-  try {
-    const deadline = Date.now() + 30000;
-    while (true) {
-      const record = readRecord(lock);
-      if (record?.operationId !== operationId) throw new Error('服务重启实例已失效。');
-      if (record.owner?.pid === process.pid) break;
-      if (Date.now() >= deadline) throw new Error('服务重启进程交接超时。');
-      await delay(100);
-    }
-    const service = lifecycle({ stateRoot, host });
-    await delay(1000);
-    await service.stop();
-    await service.start();
-  } finally {
-    if (readRecord(lock)?.operationId === operationId) fs.rmSync(lock, { force: true });
-  }
-}
-
-if (process.argv[1] && path.resolve(process.argv[1]) === script && process.argv[2] === '--worker') {
-  const [stateRoot, operationId] = process.argv.slice(3);
-  run(stateRoot, operationId).catch(error => { console.error(error.message); process.exitCode = 1; });
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { setTimeout as delay } from 'node:timers/promises';
+import { startBackground } from './background-process.mjs';
+import { lifecycle, readRecord, writeRecord } from './service-lifecycle.mjs';
+import * as host from './platform/service-host.mjs';
+import { desktopHost } from './platform/desktop-host.mjs';
+
+const script = fileURLToPath(import.meta.url);
+const sameProcess = (expected, actual) => expected && actual && expected.pid === actual.pid &&
+  expected.created === actual.created && expected.executable === actual.executable;
+async function processIdentity(pid) {
+  const current = await desktopHost.process(pid);
+  return current ? { pid: current.pid, created: current.created, executable: current.executable } : null;
+}
+
+export async function requestServiceRestart(stateRoot) {
+  const lock = path.join(stateRoot, 'service-restart.lock');
+  const operationId = randomUUID();
+  const owner = await processIdentity(process.pid);
+  if (!owner) throw new Error('无法确认服务重启请求进程。');
+  const previous = readRecord(lock);
+  if (previous) {
+    const actual = previous.owner?.pid ? await processIdentity(previous.owner.pid) : null;
+    if (sameProcess(previous.owner, actual) || readRecord(lock)?.operationId !== previous.operationId) {
+      throw new Error('工作站服务已在重启中。');
+    }
+    fs.rmSync(lock);
+  }
+  const temporary = `${lock}.${operationId}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify({ operationId, owner, requestedAt: new Date().toISOString() }),
+      { flag: 'wx', mode: 0o600 });
+    // Publish a complete record exclusively; a crash cannot leave a half-written lock.
+    fs.linkSync(temporary, lock);
+  } catch (error) {
+    if (error.code === 'EEXIST') throw new Error('工作站服务已在重启中。');
+    throw error;
+  } finally { fs.rmSync(temporary, { force: true }); }
+  try {
+    const log = path.join(stateRoot, 'service-restart.log');
+    const pid = await startBackground(process.execPath, [script, '--worker', stateRoot, operationId], process.env, [log, log]);
+    const worker = await processIdentity(pid);
+    if (!worker) throw new Error('服务重启进程未启动。');
+    const current = readRecord(lock);
+    if (current?.operationId !== operationId) throw new Error('服务重启实例已失效。');
+    writeRecord(lock, { ...current, owner: worker });
+    return { operationId, status: 'scheduled', message: '工作站服务重启已安排。' };
+  } catch (error) {
+    const current = readRecord(lock);
+    if (current?.operationId === operationId && sameProcess(current.owner, owner)) fs.rmSync(lock, { force: true });
+    throw error;
+  }
+}
+
+async function run(stateRoot, operationId) {
+  const lock = path.join(stateRoot, 'service-restart.lock');
+  try {
+    const deadline = Date.now() + 30000;
+    while (true) {
+      const record = readRecord(lock);
+      if (record?.operationId !== operationId) throw new Error('服务重启实例已失效。');
+      if (record.owner?.pid === process.pid) break;
+      if (Date.now() >= deadline) throw new Error('服务重启进程交接超时。');
+      await delay(100);
+    }
+    const service = lifecycle({ stateRoot, host });
+    await delay(1000);
+    await service.stop();
+    await service.start();
+  } finally {
+    if (readRecord(lock)?.operationId === operationId) fs.rmSync(lock, { force: true });
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === script && process.argv[2] === '--worker') {
+  const [stateRoot, operationId] = process.argv.slice(3);
+  run(stateRoot, operationId).catch(error => { console.error(error.message); process.exitCode = 1; });
+}

package/dist/src/shared-app-server.mjs

@@ -123,14 +123,18 @@ export class SharedAppServer extends EventEmitter {
     const id = ++this.sequence;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
-        this.pending.delete(id);
-        reject(Object.assign(new Error(`${method} 超时；不会自动重发，请先检查对话。`),
-          { code: 'app_server_request_timeout' }));
+        const error = Object.assign(new Error(`${method} 超时；不会自动重发，请先检查对话。`),
+          { code: 'app_server_request_timeout' });
+        if ((method === 'turn/start' || method === 'turn/steer') && this.pending.has(id)) {
+          messageDelivery.retainLateResult(this.pending.get(id), error);
+        } else { this.pending.delete(id); reject(error); }
       }, 30000);
       this.pending.set(id, { resolve, reject, timer, transform, threadId: params?.threadId });
       this.socket.send(JSON.stringify({ id, method, params }), error => {
-        if (!error || !this.pending.delete(id)) return;
-        clearTimeout(timer); reject(error);
+        const pending = this.pending.get(id);
+        if (!error || !pending) return;
+        this.pending.delete(id);
+        clearTimeout(timer); pending.reject(error);
       });
     });
   }
@@ -140,19 +144,21 @@ export class SharedAppServer extends EventEmitter {
     return events.readProjects((method, params) => this.request(method, params));
   }
 
-  async send(args) {
+  async send(args, { assertCurrent = () => {} } = {}) {
     let submitted = false;
     try {
       await this.connect();
       this.requireWritable(args.threadId);
       // Reading the live thread checks this service owns it without resume changing settings.
       const { thread } = await this.request('thread/read', { threadId: args.threadId, includeTurns: false });
+      assertCurrent();
       const status = typeof thread.status === 'string' ? thread.status : thread.status?.type;
       if (status === 'active') {
         const page = await this.request('thread/turns/list', {
           threadId: args.threadId, limit: 1, sortDirection: 'desc', itemsView: 'notLoaded',
         });
         const active = page.data?.[0];
+        assertCurrent();
         if (active?.status !== 'inProgress') throw new Error('活动轮次已变化，请刷新后再发送。');
         const { turnTrigger, ...source } = events.mobileTurnSource(args.clientUserMessageId, args.responsesapiClientMetadata?.code_relax_input === 'speech_to_text');
         submitted = true;
@@ -214,7 +220,10 @@ export class SharedAppServer extends EventEmitter {
     }
     const current = record.thread.turns?.find(turn => turn.id === (params.turn?.id || params.turnId));
     if (method === 'item/completed' && !record.hydrating && current?.itemPage?.olderCursor && !current.items.some(item => item.id === params.item?.id)) return;
-    const visibleParams = (record.hydrating || current?.itemPage?.olderCursor) && method === 'turn/completed' && Array.isArray(params.turn?.items)
+    // Current app-server completion summaries carry the terminal answer, not
+    // an unrequested history page. Its ID may be new during snapshot handoff.
+    const visibleParams = (record.hydrating || current?.itemPage?.olderCursor) && method === 'turn/completed'
+      && params.turn?.itemsView !== 'summary' && Array.isArray(params.turn?.items)
       ? { ...params, turn: { ...params.turn,
         items: params.turn.items.filter(item => current?.items?.some(loaded => loaded.id === item.id)) } }
       : params;