@walkhi/code-relax 0.1.0-beta.1

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

@@ -0,0 +1,266 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexAppServerEvents = factory();
+})(globalThis, function () {
+  function mergeItems(existing, incoming = []) {
+    for (const item of incoming) {
+      const index = existing.findIndex(current => current.id === item.id);
+      if (index < 0) existing.push(item);
+      else existing[index] = { ...existing[index], ...item };
+    }
+    return existing;
+  }
+
+  // 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', 'item/commandExecution/outputDelta'].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) {
+      if (!turn) { turn = { ...p.turn, items: p.turn.items || [] }; thread.turns.push(turn); }
+      else Object.assign(turn, { ...p.turn, items: mergeItems(turn.items || [], p.turn.items) });
+      thread.status = method === 'turn/started' ? 'active' : method === 'turn/completed' ? 'idle' : thread.status;
+    }
+    if (p.item && turn) mergeItems(turn.items, [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;
+      if (method === 'item/reasoning/summaryTextDelta') {
+        item.summary ||= []; item.summary[p.summaryIndex] = (item.summary[p.summaryIndex] || '') + p.delta;
+      }
+      if (method === 'item/reasoning/summaryPartAdded') { item.summary ||= []; item.summary[p.summaryIndex] ??= ''; }
+      if (method === 'item/commandExecution/outputDelta') item.aggregatedOutput = (item.aggregatedOutput || '') + p.delta;
+    }
+    return turn || (['thread/status/changed', 'thread/name/updated'].includes(method) ? thread.turns.at(-1) : null);
+  }
+  function mergeAvailable(previous, incoming) {
+    const result = { ...previous };
+    for (const [key, value] of Object.entries(incoming || {})) {
+      if (value === null || value === undefined) continue;
+      result[key] = typeof value === 'object' && !Array.isArray(value) ? mergeAvailable(result[key], value) : value;
+    }
+    return result;
+  }
+  function mergeUsage(snapshot, update) {
+    const limit = update.rateLimits;
+    if (!limit) return snapshot;
+    const id = limit.limitId || 'codex';
+    const buckets = { ...snapshot.rateLimitsByLimitId };
+    if (!Object.keys(buckets).length && snapshot.rateLimits) buckets[snapshot.rateLimits.limitId || 'codex'] = snapshot.rateLimits;
+    buckets[id] = mergeAvailable(buckets[id], limit);
+    const primaryId = snapshot.rateLimits?.limitId || 'codex';
+    return { ...snapshot, rateLimitsByLimitId: buckets, rateLimits: id === primaryId ? buckets[id] : snapshot.rateLimits };
+  }
+  class UsageCache {
+    constructor(changed = () => {}) { this.changed = changed; this.generation = 0; this.reset(); }
+    reset() { this.generation++; this.value = null; this.pending = null; this.updates = []; this.changed(null); }
+    update(params) {
+      if (!this.value) { this.updates.push(params); return; }
+      this.value = mergeUsage(this.value, params); this.changed(this.value);
+    }
+    read(fetchSnapshot) {
+      if (this.value) return Promise.resolve(this.value);
+      if (this.pending) return this.pending;
+      const generation = this.generation;
+      const job = Promise.resolve().then(fetchSnapshot).then(snapshot => {
+        if (generation !== this.generation) throw new Error('连接已变化，用量数据已丢弃');
+        if (!snapshot?.rateLimits) throw new Error('电脑未返回用量数据');
+        this.value = this.updates.reduce(mergeUsage, snapshot); this.updates = [];
+        this.changed(this.value); return this.value;
+      }).finally(() => { if (this.pending === job) this.pending = null; });
+      this.pending = job; return job;
+    }
+  }
+  async function readProjects(request) {
+    const projects = []; let cursor;
+    do {
+      const page = await request('project/list', { limit: 100, sortKey: 'position', sortDirection: 'asc', ...(cursor ? { cursor } : {}) });
+      projects.push(...page.data); cursor = page.nextCursor;
+    } while (cursor);
+    return projects;
+  }
+  function projectRootKey(path = '') {
+    const key = path.replace(/^\\\\\?\\/, '').replaceAll('\\', '/').replace(/\/+$/, '');
+    return /^[a-z]:\//i.test(key) || key.startsWith('//') ? key.toLowerCase() : key;
+  }
+  function orderDesktopProjects(projects, nativeProjects) {
+    const ranks = new Map();
+    nativeProjects.forEach((project, index) => {
+      for (const root of project.roots) ranks.set(projectRootKey(root.path), index);
+    });
+    // Desktop tool IDs differ from app-server IDs; retain them for task creation.
+    const local = projects.filter(project => project.hostId === 'local');
+    local.sort((a, b) => (ranks.get(projectRootKey(a.path)) ?? Infinity) - (ranks.get(projectRootKey(b.path)) ?? Infinity));
+    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);
+    let match = null, length = -1;
+    for (const project of projects) for (const root of project.roots) {
+      const key = projectRootKey(root.path);
+      if (key.length > length && (cwd === key || cwd.startsWith(key + '/'))) {
+        match = project.id; length = key.length;
+      }
+    }
+    return match;
+  }
+  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);
+    await request('thread/settings/update', { threadId, model, effort, ...(serviceTier !== undefined ? { serviceTier } : {}) });
+    // The RPC acknowledges the update. Prefer any settings notification already received,
+    // but do not wait for a second acknowledgement or require exact normalized field values.
+    if (notifications.get(threadId) === previous) {
+      contexts.set(threadId, { ...contexts.get(threadId), model, thinking: effort, ...(serviceTier !== undefined ? { serviceTier } : {}) });
+    }
+    return contexts.get(threadId);
+  }
+  const permissionPresets = {
+    ask: { permissions: ':workspace', approvalPolicy: 'on-request', approvalsReviewer: 'user' },
+    auto: { permissions: ':workspace', approvalPolicy: 'on-request', approvalsReviewer: 'guardian_subagent' },
+    full: { permissions: ':danger-full-access', approvalPolicy: 'never', approvalsReviewer: 'user' },
+  };
+  function isAutoReviewer(value) { return value === 'auto_review' || value === 'guardian_subagent'; }
+  function permissionState(settings) {
+    const sandboxPolicy = settings.sandboxPolicy ?? settings.sandbox;
+    const { approvalPolicy, approvalsReviewer, activePermissionProfile } = settings;
+    const profile = activePermissionProfile?.id;
+    let permissionMode = null;
+    // A custom profile remains custom even when its legacy sandbox looks similar.
+    if (!profile || profile.startsWith(':')) {
+      if ((profile === ':danger-full-access' || (!profile && sandboxPolicy?.type === 'dangerFullAccess')) && approvalPolicy === 'never' && approvalsReviewer === 'user') permissionMode = 'full';
+      const workspace = profile === ':workspace' || (!profile && sandboxPolicy?.type === 'workspaceWrite' && sandboxPolicy.networkAccess === false && !sandboxPolicy.excludeSlashTmp && !sandboxPolicy.excludeTmpdirEnvVar);
+      if (workspace && approvalPolicy === 'on-request') {
+        if (approvalsReviewer === 'user') permissionMode = 'ask';
+        else if (isAutoReviewer(approvalsReviewer)) permissionMode = 'auto';
+      }
+    }
+    return { approvalPolicy, approvalsReviewer, activePermissionProfile: activePermissionProfile ?? null, sandboxPolicy, permissionMode };
+  }
+  async function readPermissionOptions(request, threadId, cwd) {
+    const list = async (method, params) => {
+      const data = []; let cursor;
+      do {
+        const page = await request(method, { ...params, limit: 100, ...(cursor ? { cursor } : {}) });
+        data.push(...page.data); cursor = page.nextCursor;
+      } while (cursor);
+      return data;
+    };
+    const [profiles, features, requirements] = await Promise.all([
+      list('permissionProfile/list', cwd ? { cwd } : {}),
+      list('experimentalFeature/list', { threadId }),
+      request('configRequirements/read', {}),
+    ]);
+    return { profiles, guardianEnabled: features.some(feature => feature.name === 'guardian_approval' && feature.enabled), requirements: requirements.requirements };
+  }
+  function availablePermissionModes(options, context) {
+    const requirements = options.requirements;
+    const model = context.model?.replace(/^[A-Za-z0-9_-]+\//, '');
+    const requiresAutoReview = requirements?.autoReview?.requiredOnModels?.includes(model);
+    return Object.entries(permissionPresets).filter(([mode, preset]) => {
+      if (!options.profiles.some(profile => profile.id === preset.permissions && profile.allowed)) return false;
+      if (mode === 'auto' && !options.guardianEnabled) return false;
+      if (requiresAutoReview && mode !== 'auto') return false;
+      if (requirements?.allowedApprovalPolicies && !requirements.allowedApprovalPolicies.includes(preset.approvalPolicy)) return false;
+      if (requirements?.allowedSandboxModes && !requirements.allowedSandboxModes.includes(mode === 'full' ? 'danger-full-access' : 'workspace-write')) return false;
+      if (requirements?.allowedPermissionProfiles && requirements.allowedPermissionProfiles[preset.permissions] !== true) return false;
+      const reviewers = requirements?.allowedApprovalsReviewers;
+      return !reviewers || reviewers.includes(preset.approvalsReviewer) || (mode === 'auto' && reviewers.some(isAutoReviewer));
+    }).map(([mode]) => mode);
+  }
+  class PermissionOptionsCache {
+    constructor() { this.entries = new Map(); }
+    clear() { this.entries.clear(); }
+    delete(threadId) { this.entries.delete(threadId); }
+    context(threadId, context) {
+      const options = this.entries.get(threadId)?.value;
+      return { ...context, ...(options ? { permissionModes: availablePermissionModes(options, context) } : {}) };
+    }
+    async read(request, threadId, context) {
+      let entry = this.entries.get(threadId);
+      if (!entry || entry.cwd !== context.cwd) {
+        entry = { cwd: context.cwd };
+        entry.promise = readPermissionOptions(request, threadId, context.cwd).then(value => { entry.value = value; }).catch(error => {
+          if (this.entries.get(threadId) === entry) this.entries.delete(threadId);
+          throw error;
+        });
+        this.entries.set(threadId, entry);
+      }
+      await entry.promise;
+    }
+  }
+  async function updatePermissions(request, contexts, notifications, optionsCache, threadId, mode) {
+    if (!Object.hasOwn(permissionPresets, mode)) throw new Error('不支持的权限模式');
+    const context = contexts.get(threadId);
+    if (!context) throw new Error('请先打开对话');
+    await optionsCache.read(request, threadId, context);
+    if (!optionsCache.context(threadId, contexts.get(threadId)).permissionModes.includes(mode)) throw new Error('此主机或项目配置不支持该权限模式');
+    const previous = notifications.get(threadId), preset = permissionPresets[mode];
+    await request('thread/settings/update', { threadId, ...preset });
+    if (notifications.get(threadId) === previous) {
+      contexts.set(threadId, { ...contexts.get(threadId), ...preset, activePermissionProfile: { id: preset.permissions, extends: null }, permissionMode: mode });
+    }
+    return optionsCache.context(threadId, contexts.get(threadId));
+  }
+  async function createThread(request, target, input, settings) {
+    const { thread } = await request('thread/start', target);
+    await request('turn/start', { threadId:thread.id, input,
+      ...(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 };
+  }
+  async function readQueueItems(request, threadId) {
+    const items = []; let cursor = null;
+    do {
+      const result = await request('thread/queue/list', { threadId, cursor });
+      items.push(...result.data); cursor = result.nextCursor;
+    } while (cursor);
+    return items;
+  }
+  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'),
+      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) {
+    await request('thread/queue/add', { threadId, input, clientUserMessageId });
+    return readQueue(request, threadId);
+  }
+  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 { thread } = await request('thread/read', { threadId, includeTurns: true });
+      const active = thread.turns.findLast(turn => turn.status === 'inProgress');
+      if (active) {
+        await request('turn/steer', { threadId, expectedTurnId: active.id, input: item.input,
+          clientUserMessageId: item.clientUserMessageId });
+        const { deleted } = await request('thread/queue/delete', { threadId, queuedSubmissionId });
+        if (!deleted) throw new Error('引导已提交，但原排队消息未删除，请检查队列，勿重复引导');
+      } else {
+        await request('thread/queue/start', { threadId, queuedSubmissionId });
+      }
+    } else {
+      await request(`thread/queue/${action}`, { threadId, queuedSubmissionId });
+    }
+    return readQueue(request, threadId);
+  }
+  return { createThread, readQueue, addQueue, changeQueue, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, projectlessThreadTarget, updateSettings,
+    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
+});

package/dist/shared/p2p-diagnostics.cjs

@@ -0,0 +1,28 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodeRelaxP2pDiagnostics = factory();
+})(globalThis, () => class {
+  constructor() {
+    this.started = Date.now(); this.local = [0, 0, 0, 0, 0]; this.remote = [0, 0, 0, 0, 0];
+    this.offer = false; this.answer = false; this.open = false; this.ping = false; this.pong = false;
+    this.ice = 'new'; this.gathering = 'new'; this.error = 'none';
+  }
+  candidate(side, candidate) {
+    const type = /\btyp (host|srflx|prflx|relay)\b/.exec(candidate || '')?.[1];
+    const index = ['host', 'srflx', 'prflx', 'relay'].indexOf(type);
+    const counts = side === 'local' ? this.local : this.remote;
+    counts[index < 0 ? 4 : index]++;
+  }
+  snapshot(stage) {
+    const known = (value, choices) => choices.includes(value) ? value : 'unknown';
+    const counts = values => values.map(value => Math.min(value, 999)).join(',');
+    return `stage=${known(stage, ['verified', 'timeout', 'failed', 'closed', 'complete', 'replaced', 'unsupported'])}` +
+      `;ms=${Math.min(Date.now() - this.started, 999999)}` +
+      `;offer=${Number(this.offer)};answer=${Number(this.answer)}` +
+      `;ice=${known(this.ice, ['new', 'checking', 'connected', 'completed', 'failed', 'disconnected', 'closed'])}` +
+      `;gathering=${known(this.gathering, ['new', 'in-progress', 'gathering', 'complete'])}` +
+      `;local=${counts(this.local)};remote=${counts(this.remote)}` +
+      `;open=${Number(this.open)};ping=${Number(this.ping)};pong=${Number(this.pong)}` +
+      `;error=${known(this.error, ['none', 'stun', 'description', 'candidate', 'channel', 'frame', 'peer', 'initialization', 'signal'])}`;
+  }
+});

package/dist/shared/server-requests.cjs

@@ -0,0 +1,67 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexServerRequests = factory();
+})(globalThis, function () {
+  const command = 'item/commandExecution/requestApproval';
+  const file = 'item/fileChange/requestApproval';
+  const input = 'item/tool/requestUserInput';
+  const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  function decisions(request) {
+    if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
+    if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    return [];
+  }
+  function validate(request, result) {
+    if ([command, file].includes(request.method)) {
+      if (!result || Object.keys(result).length !== 1 || !decisions(request).some(value => equal(value, result.decision))) throw new Error('审批选项不属于当前请求');
+      return;
+    }
+    if (request.method === input) {
+      const questions = request.params.questions || [];
+      if (!result?.answers || Object.keys(result).length !== 1 || Object.keys(result.answers).length !== questions.length
+        || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
+      return;
+    }
+    throw new Error('此类请求需在工作站处理');
+  }
+  class Store {
+    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
+    list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    receive(message) {
+      if (!['string', 'number'].includes(typeof message.id) || !message.params?.threadId || this.requests.has(message.id)) return;
+      const request = { id: message.id, method: message.method, params: message.params, epoch: this.epoch, status: 'pending' };
+      this.requests.set(message.id, request); this.changed(request.params.threadId);
+    }
+    notification(method, params) {
+      if (method === 'serverRequest/resolved') {
+        const request = this.requests.get(params.requestId);
+        if (request?.params.threadId === params.threadId) { this.requests.delete(params.requestId); this.changed(params.threadId); }
+      } else if (method === 'turn/completed' || method === 'thread/closed') {
+        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) this.requests.delete(id);
+        this.changed(params.threadId);
+      }
+    }
+    forget(threadId) {
+      for (const [id, request] of this.requests) if (request.params.threadId === threadId) this.requests.delete(id);
+      this.changed(threadId);
+    }
+    reset(epoch) {
+      const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
+      this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
+    }
+    async respond(threadId, { id, epoch, result }, send) {
+      const request = this.requests.get(id);
+      if (!request || epoch !== this.epoch || request.params.threadId !== threadId) throw new Error('审批已处理或连接已变化，请等待同步');
+      if (request.status !== 'pending') throw new Error('决定已提交，正在等待工作站确认，请勿重复提交');
+      validate(request, result);
+      request.status = 'submitted'; this.changed(threadId);
+      try { await send({ id: request.id, result }); }
+      catch (error) {
+        if (this.requests.get(id) === request) { request.status = 'unknown'; this.changed(threadId); }
+        throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
+      }
+      return { submitted: true };
+    }
+  }
+  return { Store, decisions, validate, command, file, input };
+});

package/dist/shared/timeline-sync.cjs

@@ -0,0 +1,67 @@
+(function (root, factory) {
+  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);
+  function changedFields(previous, current, ignored) {
+    const set = {}, append = {}, unset = [];
+    for (const key of new Set([...Object.keys(previous || {}), ...Object.keys(current || {})])) {
+      if (ignored.has(key) || equal(previous?.[key], current?.[key])) continue;
+      if (!Object.hasOwn(current, key)) { unset.push(key); continue; }
+      const before = previous?.[key], after = current[key];
+      if (typeof before === 'string' && typeof after === 'string' && after.startsWith(before)) append[key] = after.slice(before.length);
+      else set[key] = after;
+    }
+    return { set, append, unset };
+  }
+  const nonempty = changes => Object.keys(changes.set).length || Object.keys(changes.append).length || changes.unset.length;
+  function diffTurn(previous, current) {
+    if (!previous || !current || previous.id !== current.id) return null;
+    const before = Array.isArray(previous.entries) ? previous.entries : [];
+    const after = Array.isArray(current.entries) ? current.entries : [];
+    if (after.length < before.length) return null;
+    const entries = [];
+    for (let index = 0; index < before.length; index++) {
+      if (before[index]?.id !== after[index]?.id || before[index]?.type !== after[index]?.type ||
+          before[index]?.role !== after[index]?.role || before[index]?.kind !== after[index]?.kind) return null;
+      const changes = changedFields(before[index], after[index], new Set(['id', 'type', 'role', 'kind']));
+      if (nonempty(changes)) entries.push({ id: after[index].id, index, ...changes });
+    }
+    const turn = changedFields(previous, current, new Set(['id', 'entries']));
+    const appended = after.slice(before.length);
+    return { id: current.id, ...turn, entries, appended };
+  }
+  function applyChanges(target, changes) {
+    const result = { ...target, ...(changes.set || {}) };
+    for (const key of changes.unset || []) delete result[key];
+    for (const [key, suffix] of Object.entries(changes.append || {})) {
+      if (typeof result[key] !== 'string' || typeof suffix !== 'string') throw new Error('增量字段类型不匹配');
+      result[key] += suffix;
+    }
+    return result;
+  }
+  function applyTurnPatch(turn, patch) {
+    if (!turn || turn.id !== patch?.id) throw new Error('增量轮次不存在');
+    const next = applyChanges(turn, patch), entries = (turn.entries || []).map(entry => ({ ...entry }));
+    for (const entryPatch of patch.entries || []) {
+      const entry = entries[entryPatch.index];
+      if (!entry || entry.id !== entryPatch.id) throw new Error('增量条目边界不匹配');
+      entries[entryPatch.index] = applyChanges(entry, entryPatch);
+    }
+    for (const entry of patch.appended || []) {
+      if (entries.some(existing => existing.id === entry.id)) throw new Error('增量条目重复');
+      entries.push(entry);
+    }
+    next.entries = entries; return next;
+  }
+  function acceptSyncUpdate(current, incoming) {
+    if (incoming.reset) return { reset: true, next: incoming };
+    const valid = current && incoming.id === current.id && incoming.epoch === current.epoch &&
+      Number.isSafeInteger(incoming.fromSeq) && incoming.fromSeq >= 1 &&
+      Number.isSafeInteger(incoming.toSeq) && incoming.toSeq >= incoming.fromSeq;
+    if (!valid || incoming.fromSeq > current.seq + 1) throw new Error('实时更新序号不连续');
+    if (incoming.toSeq <= current.seq) return { duplicate: true, next: current };
+    return { next: { ...current, seq: incoming.toSeq } };
+  }
+  return { diffTurn, applyTurnPatch, acceptSyncUpdate };
+});

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

@@ -0,0 +1,17 @@
+---
+name: code-relax
+description: 启动、检查或停止 Code Relax 工作站服务，生成并展示配对二维码。
+---
+
+# Code Relax
+
+- Bridge 可独立于 Desktop 启动；在 Desktop 任务中执行时保留注入环境，用于基础控制绑定上下文。启动工作站服务用 `relax start --json`；完整控制用 `relax shared-start --json`。已配置 Code Relax 中继时，启动命令同时恢复中继连接器和已有设备授权。
+- npm 全局安装会自动执行服务部署和 Skill 安装；只有修复安装时才单独运行 `relax setup --json` 或 `relax skill-install --json`。
+- `setup` 默认启用当前用户登录启动工作站服务，不自动打开 Codex；用 `autostart-status / autostart-disable / autostart-enable` 管理。恢复完整控制会保留 Bridge 和中继，但仍须明确确认可能中断全部完整控制任务。
+- 用户要求启动 Code Relax 时，执行一次 `relax start --json`。用户要求二维码或当前启动结果包含二维码时，展示 CLI 返回的 `qrPath` 和 `displayText`；没有设备授权时可用 `relax pair --json` 生成新的配对二维码。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、Bridge Token 或中继地址。新增设备不撤销已有设备。
+- 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
+- `status --json` 查询工作站服务；`relay-status --json` 查询中继和授权设备数。`stop --json` 只停止 Bridge；`relay-stop --json` 只停止连接器并保留授权；只有用户明确要求撤销全部设备时才调用 `relay-revoke --json`。
+- 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
+- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
+- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。