@walkhi/code-relax 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/shared/plan-pricing.cjs

@@ -0,0 +1,32 @@
+(function (root, factory) {
+  const pricing = factory();
+  if (typeof module === 'object' && module.exports) module.exports = pricing;
+  else root.CodeRelaxPlanPricing = pricing;
+})(globalThis, function () {
+  // Desktop 26.1007.2314.0: usage plan row reads checkout prices, not invoices.
+  async function read(accountId, get) {
+    const response = await get('/accounts/check/v4-2023-04-27');
+    const account = response?.accounts?.[accountId];
+    if (!account || account.account?.is_deactivated || account.can_access_with_session === false) return null;
+    const plan = account.account?.plan_type;
+    if (!['free', 'go', 'plus', 'prolite', 'pro', 'promax'].includes(plan)) return null;
+    const trial = account.last_active_subscription?.purchase_origin_platform === 'chatgpt_no_payment_trial';
+    const billingCurrency = trial ? null : account.entitlement?.billing_currency;
+    const selector = billingCurrency || 'US';
+    if (!/^[A-Za-z]{2,3}$/.test(selector)) return null;
+    const config = (await get(`/checkout_pricing_config/configs/${encodeURIComponent(selector)}`))?.currency_config;
+    const amount = config?.[plan]?.month?.amount;
+    const currency = config?.symbol_code;
+    if (typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0 || !/^[A-Z]{3}$/.test(currency || '')) return null;
+    if (billingCurrency && currency !== billingCurrency.toUpperCase()) return null;
+    return { accountId, plan, amount, currency, minorUnitExponent: config.minor_unit_exponent ?? null };
+  }
+  function format(value) {
+    if (!value) return '';
+    const digits = Number.isInteger(value.minorUnitExponent) && value.minorUnitExponent >= 0 && value.minorUnitExponent <= 4
+      ? value.minorUnitExponent : undefined;
+    return new Intl.NumberFormat('zh-CN', { style: 'currency', currency: value.currency, currencyDisplay: 'code',
+      minimumFractionDigits: 0, maximumFractionDigits: digits }).format(value.amount);
+  }
+  return { read, format };
+});

package/dist/shared/question-attention.cjs

@@ -0,0 +1,69 @@
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexQuestionAttention = factory();
+})(globalThis, function () {
+  function parseQuestionReply(text) {
+    const match = /^\s*<send_user_message_question_reply>\s*([\s\S]*?)\s*<\/send_user_message_question_reply>\s*$/.exec(text);
+    if (!match) return null;
+    let replies;
+    try { replies = JSON.parse(match[1]); } catch { return null; }
+    if (!Array.isArray(replies) || !replies.length || !replies.every(reply =>
+      reply && typeof reply.question === 'string' && typeof reply.answer === 'string')) return null;
+    return replies;
+  }
+
+  function questionIds(item) {
+    if (!item?.id || item.delivery !== 'async') return [];
+    return item.questions?.length
+      ? item.questions.map((_, index) => JSON.stringify(['request_user_input_async', item.id, index])) : [item.id];
+  }
+
+  // Only identities cross the catalog event channel, never question/answer bodies.
+  function fromNotification(method, params) {
+    const turnId = params.turnId || params.turn?.id;
+    if (!params.threadId || !turnId) return null;
+    if (method === 'turn/completed') return { turnId, completed: true };
+    if (method !== 'item/completed') return null;
+    const item = params.item;
+    if (item?.type === 'agentMessage') {
+      const questions = questionIds(item);
+      return questions.length ? { turnId, questions } : null;
+    }
+    if (item?.type === 'userMessage') {
+      const text = (item.content || []).filter(part => part.type === 'text').map(part => part.text).join('\n');
+      const answered = (parseQuestionReply(text) || []).map(reply => reply.questionItemId).filter(id => typeof id === 'string');
+      return answered.length ? { turnId, answered } : null;
+    }
+    return null;
+  }
+  // A successful submission is enough to dismiss a question; model consumption
+  // can happen later. Store identities only, never answers or replayable writes.
+  function createAnswerStore({ storage, scope, onError }) {
+    const records = new Map();
+    const key = thread => 'codexRemoteAnsweredQuestions:' + JSON.stringify([
+      scope(), thread.hostId || 'local', thread.id,
+    ]);
+    function read(owner) {
+      if (!records.has(owner)) {
+        try {
+          const ids = JSON.parse(storage.getItem(owner) || '[]');
+          records.set(owner, new Set(Array.isArray(ids) ? ids.filter(id => typeof id === 'string') : []));
+        } catch (error) { records.set(owner, new Set()); onError?.(error); }
+      }
+      return records.get(owner);
+    }
+    function remember(owner, ids) {
+      const answered = read(owner);
+      let changed = false;
+      for (const id of ids) if (typeof id === 'string' && !answered.has(id)) {
+        answered.add(id); changed = true;
+      }
+      if (changed) {
+        try { storage.setItem(owner, JSON.stringify([...answered])); }
+        catch (error) { onError?.(error); }
+      }
+    }
+    return { key, has: (thread, id) => read(key(thread)).has(id), remember };
+  }
+  return { parseQuestionReply, questionIds, fromNotification, createAnswerStore };
+});

package/dist/shared/server-requests.cjs

@@ -5,13 +5,118 @@
   const command = 'item/commandExecution/requestApproval';
   const file = 'item/fileChange/requestApproval';
   const input = 'item/tool/requestUserInput';
+  const elicitation = 'mcpServer/elicitation/request';
   const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const approvalId = request => 'approval:' + (request.params.turnId || '') + ':' + typeof request.id + ':' + request.id;
+  function confirmation(request) {
+    const p = request.params || {}, value = p._meta?.['openai/confirmation'], schema = p.requestedSchema;
+    if (request.method !== elicitation || p.mode !== 'form' || value?.version !== 1
+      || typeof value.field !== 'string' || schema?.type !== 'object'
+      || Object.keys(schema.properties || {}).length !== 1 || schema.properties[value.field]?.type !== 'boolean'
+      || schema.required?.length !== 1 || schema.required[0] !== value.field) return null;
+    return value;
+  }
+  function confirmationResult(request, decision) {
+    return { action: decision, content: decision === 'accept' ? { [confirmation(request).field]: true } : null, _meta: null };
+  }
+  function browserAccess(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.tool_name !== 'access_browser_origin'
+      || meta.codex_approval_kind !== 'mcp_tool_call' || meta.codex_request_type !== 'approval_request'
+      || meta.codex_sensitive_action !== true || p.requestedSchema?.type !== 'object'
+      || Object.keys(p.requestedSchema.properties || {}).length) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['http:', 'https:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+      return { origin: meta.origin, persistent: meta.persist === 'always' };
+    } catch { return null; }
+  }
+  function browserAction(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (browserAccess(request) || request.method !== elicitation || p.mode !== 'form'
+      || p.requestedSchema?.type !== 'object' || Object.keys(p.requestedSchema.properties || {}).length
+      || p.requestedSchema.required?.length || typeof p.message !== 'string' || !p.message.trim()) return null;
+    const tool = meta.codex_approval_kind === 'mcp_tool_call' && meta.connector_id === 'browser-use';
+    if (!tool && !['browser', 'browser-use'].includes(p.serverName)) return null;
+    if (meta.codex_approval_kind && meta.codex_approval_kind !== 'mcp_tool_call') return null;
+    const modes = meta.persist == null ? [] : Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if (modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    if (!tool && !modes.length) return null;
+    try {
+      const origin = new URL(meta.origin);
+      if (!['http:', 'https:'].includes(origin.protocol) || origin.origin !== meta.origin) return null;
+      return { origin: meta.origin, session: modes.includes('session'), persistent: modes.includes('always') };
+    } catch { return null; }
+  }
+  function browserActionResult(decision) {
+    return { action: decision === 'cancel' ? 'cancel' : 'accept', content: decision === 'cancel' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowSession' ? { persist: 'session' } : null };
+  }
+  function computerAppAccess(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind !== 'mcp_tool_call'
+      || (meta.codex_request_type != null && meta.codex_request_type !== 'approval_request')
+      || typeof meta.connector_id !== 'string' || p.requestedSchema?.type !== 'object'
+      || Object.keys(p.requestedSchema.properties || {}).length || p.requestedSchema.required?.length) return null;
+    const connector = meta.connector_id.trim().toLowerCase().split(/[^a-z0-9]+/g).filter(Boolean).join('-');
+    if (connector !== 'computer-use' && !connector.startsWith('computer-use-')) return null;
+    const modes = Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if (!modes.length || modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    const display = Array.isArray(meta.tool_params_display) ? meta.tool_params_display.find(entry => entry?.name === 'app')?.value : null;
+    const app = typeof display === 'string' && display.trim() ? display : meta.tool_params?.app;
+    if (typeof app !== 'string' || !app.trim()) return null;
+    return { app: app.trim(), session: modes.includes('session'), persistent: modes.includes('always'),
+      subtitle: typeof meta.subtitle === 'string' ? meta.subtitle : '', highRisk: meta.riskLevel === 'high' };
+  }
+  function computerAppResult(request, decision) {
+    const app = computerAppAccess(request);
+    return { action: decision === 'decline' ? 'decline' : 'accept', content: decision === 'decline' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowConversation' && app?.session ? { persist: 'session' } : null };
+  }
+  function mcpToolApproval(request) {
+    const p = request.params || {}, meta = p._meta || {};
+    if (request.method !== elicitation || p.mode !== 'form' || meta.codex_approval_kind !== 'mcp_tool_call'
+      || (meta.codex_request_type != null && meta.codex_request_type !== 'approval_request')
+      || p.requestedSchema?.type !== 'object' || Object.keys(p.requestedSchema.properties || {}).length
+      || p.requestedSchema.required?.length || typeof p.message !== 'string' || !p.message.trim()
+      || typeof meta.connector_id !== 'string' || !meta.connector_id.trim()
+      || !meta.tool_params || typeof meta.tool_params !== 'object' || Array.isArray(meta.tool_params)) return null;
+    const connector = meta.connector_id.trim().toLowerCase().split(/[^a-z0-9]+/g).filter(Boolean).join('-');
+    // These requests have dedicated approval semantics in Desktop.
+    if (connector === 'browser-use' || connector === 'computer-use' || connector.startsWith('computer-use-')
+      || meta.tool_name === 'access_browser_origin' || meta.tool_name === 'access_browser_origin_with_raw_cdp'
+      || meta.connector_id === 'connector_20205bf7d4e99a89d7154bb849718324') return null;
+    const modes = meta.persist === undefined ? [] : Array.isArray(meta.persist) ? meta.persist : [meta.persist];
+    if ((Array.isArray(meta.persist) && (!modes.length || modes.length > 2))
+      || modes.some(mode => !['session', 'always'].includes(mode))) return null;
+    return { session: modes.includes('session'), persistent: modes.includes('always') };
+  }
+  function mcpToolResult(decision) {
+    return { action: decision === 'decline' ? 'decline' : 'accept', content: decision === 'decline' ? null : {},
+      _meta: decision === 'allowAlways' ? { persist: 'always' }
+        : decision === 'allowSession' ? { persist: 'session' } : null };
+  }
   function decisions(request) {
+    if (confirmation(request)) return ['decline', 'accept'];
     if (request.method === command) return request.params.availableDecisions ?? ['accept', 'acceptForSession', 'decline', 'cancel'];
     if (request.method === file) return ['accept', 'acceptForSession', 'decline', 'cancel'];
+    const action = browserAction(request);
+    if (action) return ['allowOnce', ...(action.session ? ['allowSession'] : []), ...(action.persistent ? ['allowAlways'] : []), 'cancel'];
+    const app = computerAppAccess(request);
+    if (app) return ['decline', 'allowConversation', ...(app.persistent ? ['allowAlways'] : [])];
+    const browser = browserAccess(request);
+    if (browser) return browser.persistent ? ['allowOnce', 'allowSite', 'allowAllSites', 'decline'] : ['allowOnce', 'decline'];
+    const tool = mcpToolApproval(request);
+    if (tool) return ['decline', 'allowOnce', ...(tool.session ? ['allowSession'] : []), ...(tool.persistent ? ['allowAlways'] : [])];
     return [];
   }
   function validate(request, result) {
+    if (confirmation(request)) {
+      if (!decisions(request).some(decision => equal(confirmationResult(request, decision), result))) throw new Error('确认结果不属于当前请求');
+      return;
+    }
     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;
@@ -22,46 +127,93 @@
         || questions.some(q => !Array.isArray(result.answers[q.id]?.answers) || result.answers[q.id].answers.some(a => typeof a !== 'string'))) throw new Error('回答格式无效');
       return;
     }
+    if (browserAction(request)) {
+      if (!decisions(request).some(decision => equal(browserActionResult(decision), result))) throw new Error('浏览器操作决定不属于当前请求');
+      return;
+    }
+    if (computerAppAccess(request)) {
+      if (!decisions(request).some(decision => equal(computerAppResult(request, decision), result))) throw new Error('应用访问决定不属于当前请求');
+      return;
+    }
+    const browser = browserAccess(request);
+    if (browser) {
+      const allowed = [
+        { action: 'accept', content: {}, _meta: null },
+        { action: 'decline', content: null, _meta: null },
+      ];
+      if (browser.persistent) allowed.push(
+        { action: 'accept', content: {}, _meta: { persist: 'always' } },
+        { action: 'accept', content: {}, _meta: { persist: 'always', browser_use_persistent_approval_scope: 'all-sites' } },
+      );
+      if (!allowed.some(choice => equal(choice, result))) throw new Error('网站访问决定不属于当前请求');
+      return;
+    }
+    if (mcpToolApproval(request)) {
+      if (!decisions(request).some(decision => equal(mcpToolResult(decision), result))) throw new Error('工具授权决定不属于当前请求');
+      return;
+    }
     throw new Error('此类请求需在工作站处理');
   }
   class Store {
-    constructor(epoch, changed = () => {}) { this.epoch = epoch; this.changed = changed; this.requests = new Map(); }
+    constructor(epoch, changed = () => {}) {
+      this.epoch = epoch; this.changed = changed; this.requests = new Map(); this.approvalHistory = new Map();
+    }
     list(threadId) { return [...this.requests.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    history(threadId) { return [...this.approvalHistory.values()].filter(r => r.params.threadId === threadId).map(r => ({ ...r })); }
+    complete(request, status) {
+      const approval = this.approvalHistory.get(approvalId(request));
+      if (approval) { approval.status = status; approval.completedAtMs = Date.now(); }
+    }
     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' };
+      if (request.method !== input) this.approvalHistory.set(approvalId(request), {
+        type: 'approval', id: approvalId(request), requestId: request.id, method: request.method,
+        params: request.params, turnId: request.params.turnId, status: 'pending', receivedAtMs: Date.now(),
+      });
       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); }
+        if (request?.params.threadId === params.threadId) {
+          this.complete(request, 'resolved'); 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);
+        for (const [id, r] of this.requests) if (r.params.threadId === params.threadId && (method === 'thread/closed' || r.params.turnId === params.turn?.id)) {
+          this.complete(r, 'expired'); 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);
+      for (const [id, approval] of this.approvalHistory) if (approval.params.threadId === threadId) this.approvalHistory.delete(id);
       this.changed(threadId);
     }
     reset(epoch) {
       const threads = new Set([...this.requests.values()].map(r => r.params.threadId));
+      for (const request of this.requests.values()) this.complete(request, 'expired');
       this.requests.clear(); this.epoch = epoch; for (const id of threads) this.changed(id);
+      this.approvalHistory.clear();
     }
     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);
+      const approval = this.approvalHistory.get(approvalId(request));
+      if (approval) { approval.status = 'submitted'; approval.result = 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); }
+        if (this.requests.get(id) === request) {
+          request.status = 'unknown'; if (approval) approval.status = 'unknown'; this.changed(threadId);
+        }
         throw new Error('审批发送结果未确认，请检查工作站；不会自动重发。' + error.message);
       }
       return { submitted: true };
     }
   }
-  return { Store, decisions, validate, command, file, input };
+  return { Store, decisions, validate, command, file, input, elicitation, browserAccess, browserAction, browserActionResult, computerAppAccess, computerAppResult, mcpToolApproval, mcpToolResult, confirmation, confirmationResult };
 });

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": "coderelax",
+  "apiOrigin": "https://api.coderelax.cn",
+  "webOrigin": "https://www.coderelax.cn",
+  "adminOrigin": "https://admin.coderelax.cn",
+  "relayUrl": "wss://api.coderelax.cn/relay",
+  "pairingUrl": "https://www.coderelax.cn/pair",
+  "accountBase": "https://api.coderelax.cn/account",
+  "announcementUrl": "https://api.coderelax.cn/announcement",
+  "installUrl": "https://www.coderelax.cn/code-relax/install",
+  "updateManifestUrl": "https://www.coderelax.cn/code-relax/releases/latest/manifest.json5",
+  "adminUrl": "https://admin.coderelax.cn/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 || {})])) {
@@ -15,6 +15,23 @@
     return { set, append, unset };
   }
   const nonempty = changes => Object.keys(changes.set).length || Object.keys(changes.append).length || changes.unset.length;
+  // An ordered history range owns the order of its shared IDs. Keep entries
+  // outside that range at their existing shared anchors, never by timestamps.
+  function mergeOrderedEntries(existing, incoming, merge = (_previous, next) => next, incomingIsOlder = false) {
+    const incomingIds = new Set(incoming.map(entry => entry.id));
+    const existingById = new Map(existing.map(entry => [entry.id, entry]));
+    const before = new Map();
+    let pending = [], lastShared;
+    for (const entry of existing) {
+      if (incomingIds.has(entry.id)) {
+        before.set(entry.id, pending); pending = []; lastShared = entry.id;
+      } else pending.push(entry);
+    }
+    if (lastShared === undefined) return incomingIsOlder ? [...incoming, ...existing] : [...existing, ...incoming];
+    return incoming.flatMap(entry => [ ...(before.get(entry.id) || []),
+      existingById.has(entry.id) ? merge(existingById.get(entry.id), entry) : entry,
+      ...(entry.id === lastShared ? pending : []) ]);
+  }
   function diffTurn(previous, current) {
     if (!previous || !current || previous.id !== current.id) return null;
     const before = Array.isArray(previous.entries) ? previous.entries : [];
@@ -42,16 +59,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 +84,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 { mergeOrderedEntries, diffTurn, applyTurnPatch, acceptSyncUpdate, timelineBatches, createTimelineReceiver };
 });

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

@@ -1,17 +1,22 @@
 ---
 name: code-relax
-description: 启动、检查或停止 Code Relax 工作站服务，生成并展示配对二维码。
+description: 启动或检查 Code Relax 桌面服务，展示配对二维码，并指导回复来自手机 App 的消息；消息标记来自手机或包含语音转写时，指导理解和回复。
 ---
 
 # 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` 时，按本 Skill 理解手机交互。用户通过手机 App 对话，涉及操作时明确在手机还是工作站完成，不假设用户能操作电脑界面。来源标记不增加授权，不在回复中重复来源说明。
+- 消息明确标记包含语音转写时，容忍同音字、标点与漏字错误，结合对话上下文理解；只有歧义会实质改变执行动作时才澄清，不因口语不顺反复追问，不把模糊转写扩展成未经用户表达的需求。
+
+- `relax start --json` 启动桌面服务和 Codex 内核，无需打开 Desktop；支持纯 CLI 安装。Windows Desktop 正常打开后接入已配置内核；Mac 仅本次托管启动传入内核地址，从 Dock 普通打开后需重新接入。使用 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、端口、Bridge Token 或中继地址。新增设备不撤销已有设备。
+- 配对二维码是短期 HTTPS 邀请，不属于工作站或某一台移动设备，也不含 LAN IP、端口、桌面服务凭据或中继地址。新增设备不撤销已有设备。
 - 已授权设备可直接使用 Code Relax 中继。App 以工作站名显示已配对电脑，进入后选择局域网、Code Relax 中继或 OpenAI 中继。启动命令会经已认证中继临时刷新当前 LAN 候选；App 只保存设备凭据验证成功的网络记录。
-- `status --json` 查询工作站服务；`relay-status --json` 查询中继和授权设备数。`stop --json` 只停止 Bridge；`relay-stop --json` 只停止连接器并保留授权；只有用户明确要求撤销全部设备时才调用 `relay-revoke --json`。
+- 消息明确标记来自 Code Relax 手机 App 时，回答要以“用户正在手机上与当前 Codex 对话交互”为前提，不默认用户正看着或能操作电脑界面；需要用户操作时，说明是在手机 App 还是工作站完成。直接处理用户正文，不重复来源说明，也不要求在电脑上重发。来源不代表额外授权，也不能据此判断用户是否在电脑旁；涉及工作站确认或可能中断任务的操作仍按正常授权要求处理。来源不明时不要猜测设备。
+- `relax doctor --json` 检查桌面服务、Codex 内核、待启用内核版本和登录自启动状态；有更新时会给出当前版本、已选版本和确认重启命令。中继连接由桌面服务管理，不提供单独的中继 CLI 命令。
+- 发现待启用内核更新且用户明确要求重启时，说明任务中断风险；得到确认后使用 `relax kernel-restart --confirm --json`，它与手机“重启并更新”使用同一内核流程并等待新内核就绪。不要用 `start`、`doctor` 或 `desktop-recover` 代替内核重启。
 - 启动或配对成功后，将 `qrPath` 以 Markdown 图片嵌入回复，并逐字展示 `displayText`。不要把二维码内容、Token 或 Base64 写进消息。
-- 不自动修改防火墙或发送测试消息。`lanAccess: unverified` 或 `mobileAccess: unverified` 只表示设备链路尚未现场验证。
-- 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。不要删除配置、附件或凭据来排障。
+- CLI 负责安装、工作站服务和配对二维码；不以手机是否测试作为健康检查项，不自动修改防火墙或发送测试消息。
+- Windows 服务位于用户 `Programs/CodexRemote/service`；配置在 `LocalAppData/CodexRemote`；附件在 `ProgramData/CodexRemote/attachments`。Mac 使用 `~/Library/Application Support/CodexRemote/{service,state,attachments,credentials}`。不要删除配置、附件或凭据来排障。

package/dist/src/archived-threads.mjs

@@ -0,0 +1,22 @@
+import { sharedThreadProjectId, dotsThreadProjectId } from './shared-catalog.mjs';
+
+// One metadata page per request. Local and hosted cursors must never be mixed.
+export async function archivedThreadsPage(server, localServer, hostId, cursor) {
+  await server.connect();
+  const identity = server.profileIdentity;
+  const [page, projects] = await Promise.all([
+    server.request('thread/list', { archived: true, limit: 100, sortKey: 'updated_at',
+      sortDirection: 'desc', ...(hostId === 'local' ? { useStateDbOnly: true } : {}),
+      ...(cursor ? { cursor } : {}) }),
+    localServer.projects(),
+  ]);
+  if (hostId === 'durable' && identity !== server.profileIdentity) throw new Error('云端账号已变化，请重新读取归档列表。');
+  const group = hostId === 'durable' ? dotsThreadProjectId : sharedThreadProjectId;
+  return { nextCursor: page.nextCursor || null,
+    threads: page.data.filter(thread => hostId === 'durable' ? thread.threadSource === 'aeon_child' : thread.threadSource !== 'aeon')
+      .map(thread => ({ id: thread.id, hostId, kind: 'codex', threadSource: thread.threadSource,
+        title: thread.name || thread.preview || '', projectId: group(thread, projects),
+        cwd: thread.cwd, updatedAt: thread.updatedAt, recencyAt: thread.recencyAt ?? thread.updatedAt,
+        status: typeof thread.status === 'string' ? thread.status : thread.status?.type || 'unknown',
+        activeFlags: Array.isArray(thread.status?.activeFlags) ? thread.status.activeFlags : [] })) };
+}

package/dist/src/bounded-process-log.mjs

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+
+export const processLogMaxBytes = 8 * 1024 * 1024;
+const retryMs = 30_000;
+
+// The broker drains output even when storage fails, so logging cannot crash
+// the child or build an unbounded in-memory queue.
+export function attachProcessLog(stream, file, { maxBytes = processLogMaxBytes, now = Date.now } = {}) {
+  let retryAt = 0, dropped = 0, lastError = '';
+  function append(bytes) {
+    let size = 0;
+    try { size = fs.statSync(file).size; }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    // Apply the same retention bound to a log left by an earlier launch.
+    if (size > maxBytes) {
+      const fd = fs.openSync(file, 'r+');
+      try {
+        const tail = Buffer.alloc(maxBytes);
+        const count = fs.readSync(fd, tail, 0, maxBytes, size - maxBytes);
+        fs.ftruncateSync(fd, 0);
+        writeAll(fd, tail.subarray(0, count));
+        size = count;
+      } finally { fs.closeSync(fd); }
+    }
+    for (let offset = 0; offset < bytes.length;) {
+      if (size >= maxBytes) {
+        fs.rmSync(`${file}.2`, { force: true });
+        try { fs.renameSync(`${file}.1`, `${file}.2`); }
+        catch (error) { if (error.code !== 'ENOENT') throw error; }
+        fs.renameSync(file, `${file}.1`);
+        size = 0;
+      }
+      const part = bytes.subarray(offset, offset + maxBytes - size);
+      const fd = fs.openSync(file, 'a');
+      try { writeAll(fd, part); } finally { fs.closeSync(fd); }
+      offset += part.length;
+      size += part.length;
+    }
+  }
+  stream.on('data', chunk => {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (now() < retryAt) { dropped += bytes.length; return; }
+    try {
+      if (dropped) append(Buffer.from(`\n[log recovered ${new Date(now()).toISOString()}; previous error: ${lastError}; discarded output bytes: ${dropped}]\n`));
+      append(bytes);
+      dropped = 0;
+      retryAt = 0;
+    } catch (error) {
+      dropped += bytes.length;
+      lastError = error.code || error.message;
+      retryAt = now() + retryMs;
+    }
+  });
+}
+
+function writeAll(fd, bytes) {
+  let offset = 0;
+  while (offset < bytes.length) {
+    const count = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+    if (!count) throw new Error('Log write made no progress.');
+    offset += count;
+  }
+}