@walkhi/code-relax 0.1.0-beta.22 → 0.1.0-beta.23

package/dist/bin/self-relay-server.mjs

@@ -1,15 +1,16 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
+#!/usr/bin/env node
+import fs from 'node:fs';
+import serviceEndpoints from '../shared/service-endpoints.cjs';
 import { deviceStore, validId } from '../src/self-relay/device-store.mjs';
 import { openRelayMysql } from '../src/self-relay/mysql-state.mjs';
 import { startSelfRelay } from '../src/self-relay/server.mjs';
 import { updateDebugAllowlist } from '../src/self-relay/debug-allowlist.mjs';
-
-const keyFile = process.env.RELAY_HOST_KEY_FILE;
-if (!keyFile) throw new Error('RELAY_HOST_KEY_FILE is required');
-const hostKey = fs.readFileSync(keyFile, 'utf8').trim();
-const port = Number(process.env.RELAY_PORT || 45850);
-if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Invalid RELAY_PORT');
+
+const keyFile = process.env.RELAY_HOST_KEY_FILE;
+if (!keyFile) throw new Error('RELAY_HOST_KEY_FILE is required');
+const hostKey = fs.readFileSync(keyFile, 'utf8').trim();
+const port = Number(process.env.RELAY_PORT || 45850);
+if (!Number.isInteger(port) || port < 1024 || port > 65535) throw new Error('Invalid RELAY_PORT');
 const stateFile = process.env.RELAY_STATE_FILE;
 const mysqlConfigFile = process.env.RELAY_MYSQL_CONFIG_FILE;
 const accountConfigFile = process.env.RELAY_ACCOUNT_CONFIG_FILE;
@@ -40,22 +41,22 @@ if (debugCommand) {
 if (process.argv.includes('--init-state')) { if (mysqlConfigFile) throw new Error('Use migrations for MySQL mode'); deviceStore(stateFile, { initialize: true }); console.log('Device store initialized'); process.exit(0); }
 const revokeIndex = process.argv.indexOf('--revoke-host');
 if (revokeIndex >= 0) {
-  // Run only with the service stopped: this is an offline administrator operation.
-  if (!process.argv.includes('--offline')) throw new Error('Stop the relay service and supply --offline');
-  const id = process.argv[revokeIndex + 1];
-  if (!validId(id)) throw new Error('Invalid device ID');
+  // Run only with the service stopped: this is an offline administrator operation.
+  if (!process.argv.includes('--offline')) throw new Error('Stop the relay service and supply --offline');
+  const id = process.argv[revokeIndex + 1];
+  if (!validId(id)) throw new Error('Invalid device ID');
   const database = mysqlConfigFile ? await openRelayMysql(mysqlConfigFile, maxRelaySessions) : null;
   const store = database?.devices || deviceStore(stateFile), record = store.entries().find(item => item.id === id);
-  if (!record) throw new Error('Device not found');
+  if (!record) throw new Error('Device not found');
   await store.save({ ...record, status: 'revoked', clients: [], revision: record.revision + 1, updatedAt: new Date().toISOString() });
   if (database) await database.close();
-  console.log('Computer and phone authorization revoked'); process.exit(0);
-}
+  console.log('Computer and phone authorization revoked'); process.exit(0);
+}
 const relay = await startSelfRelay({ port, hostKey, stateFile, mysqlConfigFile, accountConfigFile, debugAllowlistFile, adminStateFile, maxRelaySessions,
   usageDiagnosticKeyFile: process.env.RELAY_USAGE_DIAGNOSTIC_KEY_FILE,
-  publicRelayUrl: process.env.RELAY_PUBLIC_URL || '', appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || '',
+  publicRelayUrl: process.env.RELAY_PUBLIC_URL || serviceEndpoints.relayUrl, appDownloadUrl: process.env.RELAY_APP_DOWNLOAD_URL || serviceEndpoints.installUrl,
   log: entry => console.log(JSON.stringify({ time: new Date().toISOString(), ...entry })) });
 console.log(JSON.stringify({ service: 'codex-self-relay', listen: relay.url, maxConnections: 32, maxRelaySessions,
-  maxFrameMiB: 8, encryption: 'TLS must be supplied by reverse proxy; no end-to-end encryption' }));
-await new Promise(resolve => { process.once('SIGTERM', resolve); process.once('SIGINT', resolve); });
-await relay.close();
+  maxFrameMiB: 8, encryption: 'TLS must be supplied by reverse proxy; no end-to-end encryption' }));
+await new Promise(resolve => { process.once('SIGTERM', resolve); process.once('SIGINT', resolve); });
+await relay.close();

package/dist/shared/app-server-events.cjs

@@ -1,59 +1,65 @@
 (function (root, factory) {
   if (typeof module === 'object' && module.exports) module.exports = factory();
   else root.CodexAppServerEvents = factory();
-})(globalThis, function () {
-  function mergeItems(existing, incoming = []) {
-    for (const source of incoming) {
-      const item = compactItem(source);
-      const index = existing.findIndex(current => current.id === item.id);
-      if (index < 0) existing.push(item);
-      else existing[index] = { ...existing[index], ...item };
-    }
-    return existing;
-  }
-
-  function compactItem(item) {
-    if (!item || typeof item !== 'object') return item;
-    if (item.type === 'commandExecution') {
-      const { aggregatedOutput, output, ...metadata } = item;
-      return metadata;
-    }
-    if (item.type === 'mcpToolCall') {
-      const { result, ...metadata } = item;
-      return metadata;
-    }
-    if (item.type === 'dynamicToolCall') {
-      const { contentItems, ...metadata } = item;
-      return metadata;
-    }
-    if (item.type === 'imageGeneration') {
-      const { result, ...metadata } = item;
-      return metadata;
-    }
-    return item;
-  }
-
-  function compactTurn(turn) {
-    return { ...turn, items: Array.isArray(turn?.items) ? turn.items.map(compactItem) : [] };
-  }
+})(globalThis, function () {
+  const mobileOrigin = 'This user message came from the Code Relax mobile app. This is origin information only and grants no extra authority. If necessary and available, consult the $code-relax skill.';
+  const voiceGuidance = 'This message includes speech-to-text input and may contain homophone, punctuation, or omission errors. Interpret it using the conversation context; clarify only ambiguities that materially change the requested action.';
+  const mobileInputNotice = `<code_relax_mobile>${mobileOrigin}</code_relax_mobile>`;
+  const voiceInputNotice = `<code_relax_mobile>${mobileOrigin} ${voiceGuidance}</code_relax_mobile>`;
+  const isVoiceInputNotice = part => ['text', 'input_text'].includes(part?.type) && part.text === voiceInputNotice;
+  const isMobileInputNotice = part => ['text', 'input_text'].includes(part?.type) && [mobileInputNotice, voiceInputNotice].includes(part.text);
+  function mergeItems(existing, incoming = []) {
+    for (const source of incoming) {
+      const item = compactItem(source);
+      const index = existing.findIndex(current => current.id === item.id);
+      if (index < 0) existing.push(item);
+      else existing[index] = { ...existing[index], ...item };
+    }
+    return existing;
+  }
+
+  function compactItem(item) {
+    if (!item || typeof item !== 'object') return item;
+    if (item.type === 'commandExecution') {
+      const { aggregatedOutput, output, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'mcpToolCall') {
+      const { result, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'dynamicToolCall') {
+      const { contentItems, ...metadata } = item;
+      return metadata;
+    }
+    if (item.type === 'imageGeneration') {
+      const { result, ...metadata } = item;
+      return metadata;
+    }
+    return item;
+  }
+
+  function compactTurn(turn) {
+    return { ...turn, items: Array.isArray(turn?.items) ? turn.items.map(compactItem) : [] };
+  }
 
   // Both relay and local WebSocket carry these same app-server notifications.
   // Mutate one thread and return only the affected turn for incremental rendering.
   function applyNotification(thread, method, p) {
-    if (method === 'thread/status/changed') thread.status = p.status;
-    else if (method === 'thread/name/updated') thread.name = p.threadName;
-    else if (!['turn/started', 'turn/completed', 'item/started', 'item/completed', 'item/agentMessage/delta',
-      'item/reasoning/summaryTextDelta', 'item/reasoning/summaryPartAdded'].includes(method)) return null;
+    if (method === 'thread/status/changed') thread.status = p.status;
+    else if (method === 'thread/name/updated') thread.name = p.threadName;
+    else if (!['turn/started', 'turn/completed', 'item/started', 'item/completed', 'item/agentMessage/delta',
+      'item/reasoning/summaryTextDelta', 'item/reasoning/summaryPartAdded'].includes(method)) return null;
     thread.turns ||= [];
     let turn = thread.turns.find(t => t.id === (p.turnId || p.turn?.id));
-    if (!turn && p.turnId && p.item) { turn = { id: p.turnId, status: 'inProgress', items: [] }; thread.turns.push(turn); }
-    if (p.turn) {
-      const incomingTurn = compactTurn(p.turn);
-      if (!turn) { turn = incomingTurn; thread.turns.push(turn); }
-      else Object.assign(turn, { ...incomingTurn, items: mergeItems(turn.items || [], incomingTurn.items) });
-      thread.status = method === 'turn/started' ? 'active' : method === 'turn/completed' ? 'idle' : thread.status;
-    }
-    if (p.item && turn) mergeItems(turn.items, [compactItem(p.item)]);
+    if (!turn && p.turnId && p.item) { turn = { id: p.turnId, status: 'inProgress', items: [] }; thread.turns.push(turn); }
+    if (p.turn) {
+      const incomingTurn = compactTurn(p.turn);
+      if (!turn) { turn = incomingTurn; thread.turns.push(turn); }
+      else Object.assign(turn, { ...incomingTurn, items: mergeItems(turn.items || [], incomingTurn.items) });
+      thread.status = method === 'turn/started' ? 'active' : method === 'turn/completed' ? 'idle' : thread.status;
+    }
+    if (p.item && turn) mergeItems(turn.items, [compactItem(p.item)]);
     const item = turn?.items.find(item => item.id === p.itemId);
     if (item) {
       if (method === 'item/agentMessage/delta') item.text = (item.text || '') + p.delta;
@@ -61,8 +67,8 @@
         item.summary ||= []; item.summary[p.summaryIndex] = (item.summary[p.summaryIndex] || '') + p.delta;
       }
       if (method === 'item/reasoning/summaryPartAdded') { item.summary ||= []; item.summary[p.summaryIndex] ??= ''; }
-    }
-    return turn || (['thread/status/changed', 'thread/name/updated'].includes(method) ? thread.turns.at(-1) : null);
+    }
+    return turn || (['thread/status/changed', 'thread/name/updated'].includes(method) ? thread.turns.at(-1) : null);
   }
   function mergeAvailable(previous, incoming) {
     const result = { ...previous };
@@ -125,9 +131,9 @@
     let index = 0;
     return projects.map(project => project.hostId === 'local' ? local[index++] : project);
   }
-  function threadProjectId(thread, projects) {
-    if (Object.hasOwn(thread, 'projectId')) return thread.projectId || null;
-    const cwd = projectRootKey(thread.cwd);
+  function threadProjectId(thread, projects) {
+    if (Object.hasOwn(thread, 'projectId')) return thread.projectId || null;
+    const cwd = projectRootKey(thread.cwd);
     let match = null, length = -1;
     for (const project of projects) for (const root of project.roots) {
       const key = projectRootKey(root.path);
@@ -135,23 +141,23 @@
         match = project.id; length = key.length;
       }
     }
-    return match;
-  }
-  function catalogThreadProjectId(thread, projects) {
-    if (thread.projectId) return thread.projectId;
-    const local = thread.environments?.find(environment => environment.environmentId === 'local');
-    if (local && Array.isArray(local.runtimeWorkspaceRoots)) {
-      for (const root of local.runtimeWorkspaceRoots) {
-        const projectId = threadProjectId({ cwd: root }, projects);
-        if (projectId) return projectId;
-      }
-      return null;
-    }
-    return threadProjectId({ cwd: thread.cwd }, projects);
-  }
-  function projectlessThreadTarget(cwd = '') {
-    return { projectId: null, runtimeWorkspaceRoots: [], ...(cwd ? { cwd } : {}) };
-  }
+    return match;
+  }
+  function catalogThreadProjectId(thread, projects) {
+    if (thread.projectId) return thread.projectId;
+    const local = thread.environments?.find(environment => environment.environmentId === 'local');
+    if (local && Array.isArray(local.runtimeWorkspaceRoots)) {
+      for (const root of local.runtimeWorkspaceRoots) {
+        const projectId = threadProjectId({ cwd: root }, projects);
+        if (projectId) return projectId;
+      }
+      return null;
+    }
+    return threadProjectId({ cwd: thread.cwd }, projects);
+  }
+  function projectlessThreadTarget(cwd = '') {
+    return { projectId: null, runtimeWorkspaceRoots: [], ...(cwd ? { cwd } : {}) };
+  }
   async function updateSettings(request, contexts, notifications, threadId, model, effort, serviceTier) {
     if (serviceTier !== undefined && serviceTier !== null && !['priority', 'fast'].includes(serviceTier)) throw new Error('不支持的快速模式设置');
     const previous = notifications.get(threadId);
@@ -250,17 +256,17 @@
     }
     return optionsCache.context(threadId, contexts.get(threadId));
   }
-  async function createThread(request, target, input, settings) {
-    const { thread } = await request('thread/start', target);
-    const started = await request('turn/start', { threadId:thread.id, input,
-      ...mobileTurnSource(settings.clientUserMessageId),
+  async function createThread(request, target, input, settings) {
+    const { thread } = await request('thread/start', target);
+    const started = await request('turn/start', { threadId:thread.id, input,
+      ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput),
       ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
       ...(settings.model ? { model:settings.model } : {}),
       ...(settings.thinking ? { effort:settings.thinking } : {}),
       ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
-    return { threadId:thread.id, turnId:started?.turn?.id || null };
+    return { threadId:thread.id, turnId:started?.turn?.id || null };
   }
-  async function readQueueItems(request, threadId) {
+  async function readQueueItems(request, threadId) {
     const items = []; let cursor = null;
     do {
       const result = await request('thread/queue/list', { threadId, cursor });
@@ -271,28 +277,29 @@
   async function readQueue(request, threadId) {
     const items = await readQueueItems(request, threadId);
     return { items: items.map(item => ({ id: item.id, clientUserMessageId: item.clientUserMessageId,
-      prompt: item.input.filter(part => part.type === 'text').map(part => part.text).join('\n') || '图片',
-      text: item.input.filter(part => part.type === 'text').map(part => part.text).join('\n'),
+      prompt: item.input.filter(part => part.type === 'text' && !isMobileInputNotice(part)).map(part => part.text).join('\n') || '图片',
+      text: item.input.filter(part => part.type === 'text' && !isMobileInputNotice(part)).map(part => part.text).join('\n'),
       attachments: item.input.filter(part => ['image', 'localImage'].includes(part.type)).map(part => part.type === 'image'
         ? { type:'image', available:true, url:part.url } : { type:'image', available:false, remotePath:part.path }),
       createdAt: item.createdAt ?? '', error: '', native: true })) };
   }
-  async function addQueue(request, threadId, input, clientUserMessageId) {
+  async function addQueue(request, threadId, input, clientUserMessageId, containsVoiceInput = false) {
+    input = [...input, { type: 'text', text: containsVoiceInput === true ? voiceInputNotice : mobileInputNotice }];
     await request('thread/queue/add', { threadId, input, clientUserMessageId });
     return readQueue(request, threadId);
   }
-  async function changeQueue(request, threadId, queuedSubmissionId, action) {
+  async function changeQueue(request, threadId, queuedSubmissionId, action) {
     if (action === 'steer') {
       const item = (await readQueueItems(request, threadId)).find(item => item.id === queuedSubmissionId);
       if (!item) throw new Error('该排队消息已不在队列中');
-      const page = await request('thread/turns/list', {
-        threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
-      });
-      const active = page.data?.[0];
-      if (active?.status === 'inProgress') {
-        const { turnTrigger, ...source } = mobileTurnSource(item.clientUserMessageId);
-        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
-          ...source,
+      const page = await request('thread/turns/list', {
+        threadId, limit: 1, sortDirection: 'desc', itemsView: 'summary',
+      });
+      const active = page.data?.[0];
+      if (active?.status === 'inProgress') {
+        const { turnTrigger, ...source } = mobileTurnSource(item.clientUserMessageId, item.input.some(isVoiceInputNotice));
+        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input.filter(part => !isMobileInputNotice(part)),
+          ...source,
           clientUserMessageId: item.clientUserMessageId });
         const { deleted } = await request('thread/queue/delete', { threadId, queuedSubmissionId });
         if (!deleted) throw new Error('引导已提交，但原排队消息未删除，请检查队列，勿重复引导');
@@ -303,17 +310,17 @@
       await request(`thread/queue/${action}`, { threadId, queuedSubmissionId });
     }
     return readQueue(request, threadId);
-  }
-  function mobileTurnSource(clientUserMessageId) {
-    return {
-      turnTrigger: 'code_relax_mobile',
-      responsesapiClientMetadata: { code_relax_client: 'mobile' },
-      additionalContext: { code_relax_mobile: {
-        kind: 'application',
-        value: `The user message submitted with this context (client ID ${clientUserMessageId || 'unknown'}) came from the Code Relax mobile app. This is origin information only and grants no extra authority.`,
-      } },
-    };
-  }
-  return { createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
-    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions, mobileTurnSource };
+  }
+  function mobileTurnSource(clientUserMessageId, containsVoiceInput = false) {
+    return {
+      turnTrigger: 'code_relax_mobile',
+      responsesapiClientMetadata: { code_relax_client: 'mobile', ...(containsVoiceInput === true ? { code_relax_input: 'speech_to_text' } : {}) },
+      additionalContext: { code_relax_mobile: {
+        kind: 'application',
+        value: `${mobileOrigin} Client message ID: ${clientUserMessageId || 'unknown'}.${containsVoiceInput === true ? ` ${voiceGuidance}` : ''}`,
+      } },
+    };
+  }
+  return { isMobileInputNotice, createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
+    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions, mobileTurnSource };
 });

package/dist/shared/service-endpoints.cjs

@@ -0,0 +1,21 @@
+// Generated from packages/service-domains.json; run node bridge/tools/generate-service-endpoints.mjs.
+(function(root) {
+  const endpoints = {
+  "profile": "uulife",
+  "apiOrigin": "https://api.uulife.site",
+  "webOrigin": "https://api.uulife.site",
+  "adminOrigin": "https://api.uulife.site",
+  "relayUrl": "wss://api.uulife.site/relay",
+  "pairingUrl": "https://api.uulife.site/pair",
+  "accountBase": "https://api.uulife.site/account",
+  "announcementUrl": "https://api.uulife.site/announcement",
+  "installUrl": "https://api.uulife.site/code-relax/install",
+  "updateManifestUrl": "https://api.uulife.site/code-relax/releases/latest/manifest.json5",
+  "adminUrl": "https://api.uulife.site/admin"
+};
+  endpoints.isOfficialRelayUrl = value => ["wss://api.uulife.site/relay","wss://api.coderelax.cn/relay"].includes(value);
+  endpoints.resolveRelayUrl = value => endpoints.isOfficialRelayUrl(value) ? endpoints.relayUrl : value;
+  endpoints.webOrigins = ["https://api.uulife.site","https://www.coderelax.cn"];
+  if (typeof module !== 'undefined' && module.exports) module.exports = Object.freeze(endpoints);
+  else root.CodeRelaxEndpoints = Object.freeze(endpoints);
+})(globalThis);

package/dist/shared/timeline-sync.cjs

@@ -2,7 +2,7 @@
   if (typeof module === 'object' && module.exports) module.exports = factory();
   else root.CodexTimelineSync = factory();
 })(globalThis, function () {
-  const equal = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+  const equal = (left, right) => left === right || JSON.stringify(left) === JSON.stringify(right);
   function changedFields(previous, current, ignored) {
     const set = {}, append = {}, unset = [];
     for (const key of new Set([...Object.keys(previous || {}), ...Object.keys(current || {})])) {
@@ -42,16 +42,20 @@
   }
   function applyTurnPatch(turn, patch) {
     if (!turn || turn.id !== patch?.id) throw new Error('增量轮次不存在');
-    const next = applyChanges(turn, patch), entries = (turn.entries || []).map(entry => ({ ...entry }));
+    const next = applyChanges(turn, patch), entries = [...(turn.entries || [])];
     for (const entryPatch of patch.entries || []) {
-      const entry = entries[entryPatch.index];
+      const index = entries.findIndex(entry => entry.id === entryPatch.id);
+      const entry = entries[index];
       if (!entry || entry.id !== entryPatch.id) throw new Error('增量条目边界不匹配');
-      entries[entryPatch.index] = applyChanges(entry, entryPatch);
+      entries[index] = applyChanges(entry, entryPatch);
     }
     for (const entry of patch.appended || []) {
       if (entries.some(existing => existing.id === entry.id)) throw new Error('增量条目重复');
       entries.push(entry);
     }
+    if (turn.itemPage && next.itemPage) next.itemPage = { ...next.itemPage,
+      olderCursor: turn.itemPage.olderCursor, hasLoadedOldest: turn.itemPage.hasLoadedOldest,
+      oldestItemId: turn.itemPage.oldestItemId };
     next.entries = entries; return next;
   }
   function acceptSyncUpdate(current, incoming) {
@@ -63,5 +67,90 @@
     if (incoming.toSeq <= current.seq) return { duplicate: true, next: current };
     return { next: { ...current, seq: incoming.toSeq } };
   }
-  return { diffTurn, applyTurnPatch, acceptSyncUpdate };
+  // A batch is acknowledged after consumption. Only an individual record is
+  // reassembled; the timeline itself is never serialized into one large string.
+  function* timelineBatches(timeline) {
+    function* entryRecords(value, kind, textField = '') {
+      const text = textField ? value[textField]?.text : value.text;
+      if (typeof text !== 'string' || text.length <= 4096) { yield { kind, value }; return; }
+      const metadata = textField ? { ...value, [textField]: { ...value[textField], text: '' } } : { ...value, text: '' };
+      yield { kind: 'entry-start', value: metadata, target: kind, textField };
+      for (let offset = 0; offset < text.length; offset += 4096) yield { kind: 'entry-text', value: text.slice(offset, offset + 4096) };
+      yield { kind: 'entry-end' };
+    }
+    function* records() {
+      const { turns, turnPatches, ...metadata } = timeline;
+      yield { kind: 'timeline', value: metadata };
+      for (const turn of turns) {
+        const { entries, ...metadata } = turn;
+        yield { kind: 'turn', value: metadata };
+        for (const entry of entries || []) yield* entryRecords(entry, 'entry');
+      }
+      for (const patch of turnPatches || []) {
+        const { entries, appended, ...metadata } = patch;
+        yield { kind: 'patch', value: metadata };
+        for (const entry of entries || []) yield* entryRecords(entry, 'patch-entry', entry.append?.text ? 'append' : 'set');
+        for (const entry of appended || []) yield* entryRecords(entry, 'patch-appended');
+      }
+    }
+    const encoder = new TextEncoder();
+    let batch = [], bytes = 0;
+    for (const record of records()) {
+      const json = JSON.stringify(record);
+      for (let offset = 0; offset < json.length; offset += 4096) {
+        const piece = { text: json.slice(offset, offset + 4096), end: offset + 4096 >= json.length };
+        const size = encoder.encode(JSON.stringify(piece)).length;
+        if (batch.length && bytes + size > 48 * 1024) { yield batch; batch = []; bytes = 0; }
+        batch.push(piece); bytes += size;
+      }
+    }
+    if (batch.length) yield batch;
+  }
+  function createTimelineReceiver() {
+    let timeline, turn, patch, entry, entryTarget, textField, textLength = 0, textParts = [], sequence = 0, parts = [], length = 0;
+    return {
+      accept(batch, pieces) {
+        if (batch !== ++sequence || !Array.isArray(pieces)) throw new Error('历史条目批次不连续');
+        const added = [];
+        const commitEntry = (target, value) => {
+          if (target === 'entry' && turn) { turn.entries.push(value); added.push({ turn, entry: value }); }
+          else if (target === 'patch-entry' && patch) patch.entries.push(value);
+          else if (target === 'patch-appended' && patch) patch.appended.push(value);
+          else throw new Error('历史条目目标无效');
+        };
+        for (const piece of pieces) {
+          if (typeof piece.text !== 'string' || typeof piece.end !== 'boolean') throw new Error('历史条目格式无效');
+          parts.push(piece.text); length += piece.text.length;
+          if (length > 32 * 1024 * 1024) throw new Error('单条历史内容超过接收限制');
+          if (!piece.end) continue;
+          const record = JSON.parse(parts.join('')); parts = []; length = 0;
+          if (entry && !['entry-text', 'entry-end'].includes(record.kind)) throw new Error('历史正文传输未完成');
+          if (record.kind === 'timeline' && !timeline) timeline = { ...record.value, turns: [] };
+          else if (record.kind === 'turn' && timeline) {
+            turn = { ...record.value, entries: [] }; timeline.turns.push(turn);
+          } else if (['entry', 'patch-entry', 'patch-appended'].includes(record.kind)) {
+            commitEntry(record.kind, record.value);
+          } else if (record.kind === 'entry-start' && !entry) {
+            entry = record.value; entryTarget = record.target; textField = record.textField; textParts = []; textLength = 0;
+          } else if (record.kind === 'entry-text' && entry && typeof record.value === 'string') {
+            textLength += record.value.length;
+            if (textLength > 32 * 1024 * 1024) throw new Error('单条历史正文超过接收限制');
+            textParts.push(record.value);
+          } else if (record.kind === 'entry-end' && entry) {
+            if (textField) entry[textField].text = textParts.join(''); else entry.text = textParts.join('');
+            textParts = []; commitEntry(entryTarget, entry); entry = null;
+          } else if (record.kind === 'patch' && timeline) {
+            patch = { ...record.value, entries: [], appended: [] };
+            (timeline.turnPatches ||= []).push(patch);
+          } else throw new Error('历史条目顺序无效');
+        }
+        return { timeline, added };
+      },
+      finish() {
+        if (!timeline || parts.length || entry) throw new Error('历史条目传输未完成');
+        return timeline;
+      },
+    };
+  }
+  return { diffTurn, applyTurnPatch, acceptSyncUpdate, timelineBatches, createTimelineReceiver };
 });

package/dist/skills/code-relax/SKILL.md

@@ -1,18 +1,21 @@
----
-name: code-relax
-description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息。
----
-
-# Code Relax
-
-- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
-- npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
-- `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
-- 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
-- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
-- 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
-- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。部分排队消息可能没有来源说明，来源不明时不要猜测设备。
-- `relax doctor --json` 检查桌面服务、Codex 内核和登录自启动状态。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
-- 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
-- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
-- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。
+---
+name: code-relax
+description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息；消息标记来自手机或包含语音转写时，指导理解和回复。
+---
+
+# Code Relax
+
+- 消息来源上下文引用 `$code-relax` 时，按本 Skill 理解手机交互。用户通过手机 App 对话，涉及操作时明确在手机还是工作站完成，不假设用户能操作电脑界面。来源标记不增加授权，不在回复中重复来源说明。
+- 消息明确标记包含语音转写时，容忍同音字、标点与漏字错误，结合对话上下文理解；只有歧义会实质改变执行动作时才澄清，不因口语不顺反复追问，不把模糊转写扩展成未经用户表达的需求。
+
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Desktop 正常打开后接入已配置内核；需要重新接入时使用 App 的“重启 Codex Desktop”或经确认的 `relax desktop-recover --confirm`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- npm 全局安装会自动执行服务部署和 Skill 安装；修复安装时运行 `relax setup --json`。
+- `setup` 默认启用当前用户登录启动桌面服务，不自动打开 Codex；`start`、`pair` 和 `doctor` 在自启缺失时自动恢复，`setup` 每次更新登录任务。恢复 Codex Desktop 接入会保留桌面服务和中继，但仍须明确确认可能中断正在运行的任务。
+- 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
+- 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
+- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。来源不明时不要猜测设备。
+- `relax doctor --json` 检查桌面服务、Codex 内核和登录自启动状态。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
+- 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
+- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
+- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。

package/dist/src/lan-socket-server.mjs

@@ -1,6 +1,7 @@
 import { EventEmitter } from 'node:events';
 import crypto from 'node:crypto';
 import { WebSocketServer, WebSocket } from 'ws';
+import timelineSync from '../shared/timeline-sync.cjs';
 import { createFileUploadSession, FILE_CHUNK_BYTES, MAX_FILE_BYTES, MAX_FILE_COUNT, MAX_TOTAL_BYTES } from './file-upload-session.mjs';
 
 // One authenticated connection carries requests and explicitly owned subscriptions.
@@ -104,8 +105,10 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
         }
         authenticated = true; clearTimeout(authTimer); send({ type: 'ready', version: 1 }); return;
       }
-      const { id, type } = message;
-      if (!Number.isSafeInteger(id) || id < 1) { ws.close(1008, 'Invalid request id'); return; }
+      const { id, type } = message;
+      if (!Number.isSafeInteger(id) || id < 1) { ws.close(1008, 'Invalid request id'); return; }
+      if (type === 'response-ack') { active.get(id)?.acknowledge?.(message.batch); return; }
+      if (type === 'cancel') { active.get(id)?.end(); return; }
       if (type === 'unsubscribe') { const reply = active.get(id); if (reply?.subscription) reply.end(); return; }
       if (!['request', 'subscribe'].includes(type) || active.has(id)) { ws.close(1008, 'Invalid request'); return; }
       const subscription = type === 'subscribe';
@@ -121,21 +124,58 @@ export function attachLanSocket(server, { token, dispatch, authorizeDevice = ()
           (message.body !== undefined && (!message.body || typeof message.body !== 'object' || Array.isArray(message.body)))) {
         send({ type: 'response', id, status: 400, body: { error: '无效的连接请求' } }); return;
       }
-      const reply = new EventEmitter();
-      Object.assign(reply, {
+      const reply = new EventEmitter();
+      let waiting, batch = 0;
+      const sendTimeline = async (status, body, event) => {
+        batch = 0;
+        try {
+          for (const pieces of timelineSync.timelineBatches(body)) {
+            if (reply.writableEnded) return;
+            await new Promise((resolve, reject) => {
+              const timer = setTimeout(() => reject(new Error('历史接收确认超时')), 20000);
+              waiting = { resolve, reject, timer, batch: ++batch };
+              send({ type: event ? 'event-part' : 'response-part', id, batch, pieces });
+            });
+          }
+          if (!reply.writableEnded) {
+            send(event ? { type: 'event', id, event, streamed: true } : { type: 'response', id, status, streamed: true });
+            if (!event) reply.end();
+          }
+        } catch (error) {
+          if (!reply.writableEnded) {
+            send(event ? { type: 'event', id, event: 'bridge-error', data: { error: error.message } }
+              : { type: 'response', id, status: 500, body: { error: error.message } });
+            reply.end();
+          }
+        }
+      };
+      Object.assign(reply, {
         subscription, headersSent: false, writableEnded: false, destroyed: false,
-        json(status, body) {
-          if (this.writableEnded) return;
-          send({ type: 'response', id, status, body }); this.end();
-        },
+        json(status, body) {
+          if (this.writableEnded) return;
+          if (status < 400 && body?.schemaVersion === 1 && Array.isArray(body.turns)) {
+            void sendTimeline(status, body); return;
+          }
+          send({ type: 'response', id, status, body }); this.end();
+        },
+        acknowledge(sequence) {
+          if (!waiting || sequence !== waiting.batch) return;
+          const completed = waiting; waiting = null; clearTimeout(completed.timer);
+          this.emit('progress'); completed.resolve();
+        },
         startEvents() {
           if (this.writableEnded) return;
           this.headersSent = true; send({ type: 'subscribed', id });
         },
-        event(event, data) { if (!this.writableEnded) send({ type: 'event', id, event, data }); },
+        event(event, data) {
+          if (this.writableEnded) return;
+          if (event === 'update' && data?.schemaVersion === 1) return sendTimeline(200, data, event);
+          send({ type: 'event', id, event, data });
+        },
         end() {
           if (this.writableEnded) return;
-          this.writableEnded = this.destroyed = true; active.delete(id);
+          this.writableEnded = this.destroyed = true; active.delete(id);
+          if (waiting) { clearTimeout(waiting.timer); waiting.reject(new Error('历史读取已取消')); waiting = null; }
           if (subscription) send({ type: 'end', id });
           this.emit('close');
         },