@walkhi/code-relax 0.1.0-beta.9 → 0.1.0-beta.91

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

@@ -1,19 +1,42 @@
-(function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexAppServerEvents = factory();
-})(globalThis, function () {
+(function (root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('./timeline-sync.cjs').mergeOrderedEntries, require('./file-changes.cjs'));
+  else root.CodexAppServerEvents = factory((...args) => root.CodexTimelineSync.mergeOrderedEntries(...args), root.CodexFileChanges);
+})(globalThis, function (mergeOrderedEntries, fileChanges) {
+  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 parseCodexDelegation(value) {
+    if (typeof value !== 'string') return null;
+    const text = value.trim();
+    if (!text.startsWith('<codex_delegation>') || !text.endsWith('</codex_delegation>')) return null;
+    const source = /<source_thread_id>\s*([\s\S]*?)\s*<\/source_thread_id>/i.exec(text)?.[1]?.trim();
+    const input = /<input>\s*([\s\S]*?)\s*<\/input>/i.exec(text)?.[1];
+    if (!source || input === undefined) return null;
+    return { sourceThreadId: source, input: input.replace(/&lt;/g, '<').replace(/&gt;/g, '>')
+      .replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, '&').trim() };
+  }
+  function toolDelegation(item) {
+    if (item?.type !== 'functionCallOutput' || !(item.namespace === 'codex_app'
+      && ['create_thread', 'send_message_to_thread', 'handoff_thread'].includes(item.name)
+      || item.namespace === 'cloud_threads' && item.name === 'send_message')) return null;
+    return parseCodexDelegation(typeof item.output === 'string' ? item.output : item.output?.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 === 'fileChange') return { ...item, changes: fileChanges.summarize(item.changes) };
     if (item.type === 'commandExecution') {
       const { aggregatedOutput, output, ...metadata } = item;
       return metadata;
@@ -27,6 +50,7 @@
       return metadata;
     }
     if (item.type === 'imageGeneration') {
+      if (!item.savedPath) return item;
       const { result, ...metadata } = item;
       return metadata;
     }
@@ -36,259 +60,452 @@
   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) {
+
+  const snapshotUpdates = new WeakMap();
+  function beginSnapshot(thread) {
+    const updates = new Map();
+    const previousOrder = new Map((thread.turns || []).map(turn => [turn.id, (turn.items || []).map(item => item.id)]));
+    snapshotUpdates.set(thread, updates);
+    return {
+      changed: () => updates.size > 0,
+      merge(page) {
+        const current = thread.turns.find(turn => turn.id === page.id);
+        if (!current) return page;
+        const changed = updates.get(page.id);
+        const pageIds = new Set(page.items.map(item => item.id));
+        const items = page.items.map(item => ({ ...item }));
+        for (const item of current.items || []) {
+          if (!changed?.has(item.id)) continue;
+          const index = items.findIndex(value => value.id === item.id);
+          if (index < 0) { items.push(item); continue; }
+          const previous = items[index];
+          const merged = { ...previous, ...item };
+          // A started/delta notification can describe only a prefix of the
+          // snapshot. A completed item is an explicit replacement instead.
+          if (!changed.get(item.id)) {
+            if (typeof previous.text === 'string' && typeof item.text === 'string'
+              && previous.text.startsWith(item.text)) merged.text = previous.text;
+            if (Array.isArray(previous.summary) && Array.isArray(item.summary)) {
+              merged.summary = previous.summary.map((text, i) =>
+                typeof text === 'string' && text.startsWith(item.summary[i] || '') ? text : item.summary[i]);
+              merged.summary.push(...item.summary.slice(previous.summary.length));
+            }
+          }
+          items[index] = merged;
+        }
+        // Keep the turn object used by queued live updates and catchup records.
+        const byId = new Map(items.map(item => [item.id, item]));
+        const retained = (previousOrder.get(page.id) || []).filter(id => pageIds.has(id) || changed?.has(id)).map(id => byId.get(id));
+        const ordered = mergeOrderedEntries(retained,
+          page.items.map(item => byId.get(item.id)), (_live, item) => item, true);
+        const included = new Set(ordered.map(item => item.id));
+        for (const item of current.items || []) if (changed?.has(item.id) && !included.has(item.id)) ordered.push(byId.get(item.id));
+        Object.assign(current, { ...page, ...current, items: ordered, itemPage: page.itemPage });
+        return current;
+      },
+      close() { if (snapshotUpdates.get(thread) === updates) snapshotUpdates.delete(thread); },
+    };
+  }
+
+  // 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',
+    else if (!['error', '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));
+    thread.turns ||= [];
+    let turn = thread.turns.find(t => t.id === (p.turnId || p.turn?.id));
+    if (method === 'error') {
+      if (!turn) return null;
+      turn.runtimeNotice = { ...p.error, willRetry: p.willRetry === true };
+      if (!p.willRetry) turn.error = p.error;
+      return turn;
+    }
     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;
+      const updatedAt = method === 'turn/completed' ? p.turn.completedAt : method === 'turn/started' ? p.turn.startedAt : null;
+      if (Number(updatedAt) > 0) thread.updatedAt = Math.max(Number(thread.updatedAt) || 0, Math.floor(Number(updatedAt)));
     }
+    if (turn && (method.startsWith('item/') || method === 'turn/completed' || method === 'turn/started')) turn.runtimeNotice = null;
     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;
-      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] ??= ''; }
+    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] ??= ''; }
+    }
+    const updates = snapshotUpdates.get(thread);
+    if (turn && updates) {
+      if (!updates.has(turn.id)) updates.set(turn.id, new Map());
+      const changed = updates.get(turn.id);
+      for (const id of [p.item?.id, p.itemId, ...(p.turn?.items || []).map(value => value.id)]) {
+        if (id) changed.set(id, changed.get(id) || method === 'item/completed' || method === 'turn/completed');
+      }
     }
     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 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.pending) this.updates.push(params);
+      if (!this.value) return;
+      this.value = mergeUsage(this.value, params); this.changed(this.value);
+    }
+    read(fetchSnapshot) {
+      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; if (this.value) this.updates = []; }
+      });
+      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;
-      }
-    }
+    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 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);
-    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('该排队消息已不在队列中');
+  async function updateSettings(request, contexts, threadId, model, effort, serviceTier) {
+    if (serviceTier !== undefined && serviceTier !== null && !['priority', 'fast'].includes(serviceTier)) throw new Error('不支持的快速模式设置');
+    await request('thread/settings/update', { threadId, model, effort, ...(serviceTier !== undefined ? { serviceTier } : {}) });
+    // The RPC only acknowledges queuing. Current settings come from
+    // thread/settings/updated, including any server-normalized values.
+    return contexts.get(threadId);
+  }
+  const permissionPresets = {
+    ask: { permissions: ':workspace', approvalPolicy: 'on-request', approvalsReviewer: 'user' },
+    auto: { permissions: ':workspace', approvalPolicy: 'on-request', approvalsReviewer: 'auto_review' },
+    full: { permissions: ':danger-full-access', approvalPolicy: 'never', approvalsReviewer: 'user' },
+  };
+  function isAutoReviewer(value) { return value === 'auto_review'; }
+  const globalPermissionKey = 'code-relax-approval-mode';
+  async function readGlobalPermissions(request, context = {}, optionsCache = new PermissionOptionsCache(), threadId = '') {
+    const { config } = await request('config/read', { includeLayers: false });
+    const preferred = config.desktop?.[globalPermissionKey] ?? context.desktopPermissionMode;
+    await optionsCache.read(request, threadId, context);
+    const configured = permissionState({ approvalPolicy: config.approval_policy,
+      approvalsReviewer: config.approvals_reviewer ?? 'user',
+      activePermissionProfile: config.default_permissions ? { id: config.default_permissions } : null,
+      sandboxPolicy: config.sandbox_mode === 'danger-full-access' ? { type: 'dangerFullAccess' }
+        : config.sandbox_mode === 'workspace-write' ? { type: 'workspaceWrite', networkAccess: config.sandbox_workspace_write?.network_access === true } : null });
+    return { ...optionsCache.context(threadId, context),
+      permissionMode: Object.hasOwn(permissionPresets, preferred) ? preferred : context.permissionMode ?? configured.permissionMode,
+      globalPermissionMode: Object.hasOwn(permissionPresets, preferred) ? preferred : null };
+  }
+  async function writeGlobalPermissions(request, mode, context = {}, optionsCache, threadId = '') {
+    if (!Object.hasOwn(permissionPresets, mode)) throw new Error('不支持的审批方式');
+    const current = await readGlobalPermissions(request, context, optionsCache, threadId);
+    if (!current.permissionModes.includes(mode)) throw new Error('此主机或项目配置不支持该审批方式');
+    const result = await request('config/batchWrite', { edits: [{ keyPath: `desktop.${globalPermissionKey}`,
+      value: mode, mergeStrategy: 'upsert' }], filePath: null, expectedVersion: null });
+    if (result.status !== 'ok') throw new Error('全局审批方式被其他配置覆盖，请核对配置');
+    const confirmed = await readGlobalPermissions(request, context, optionsCache, threadId);
+    if (confirmed.globalPermissionMode !== mode) throw new Error('全局审批方式未确认，请以当前显示为准');
+    return confirmed;
+  }
+  async function globalPermissionOverrides(request, context = {}, threadId = '') {
+    const { config } = await request('config/read', { includeLayers: false });
+    const mode = config.desktop?.[globalPermissionKey] ?? context.desktopPermissionMode;
+    if (!Object.hasOwn(permissionPresets, mode)) return {};
+    const options = await readPermissionOptions(request, threadId, context.cwd);
+    if (!availablePermissionModes(options, context).includes(mode)) throw new Error('全局审批方式不符合当前项目或模型的权限限制，请先调整审批方式');
+    return { ...permissionPresets[mode] };
+  }
+  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 ? { 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);
+    }).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;
+    }
+  }
+  class SettingsNotifications extends Map {
+    constructor() { super(); this.permissionWaiters = new Map(); }
+    set(threadId, settings) {
+      super.set(threadId, settings);
+      const waiter = this.permissionWaiters.get(threadId);
+      if (waiter && permissionState(settings).permissionMode === waiter.mode) waiter.finish(settings);
+      return this;
+    }
+    waitForPermission(threadId, mode, timeoutMs = 10_000) {
+      if (this.permissionWaiters.has(threadId)) throw new Error('该对话的权限变更正在等待内核确认');
+      let finish, settled = false;
+      const promise = new Promise(resolve => {
+        const timer = setTimeout(() => finish(new Error('权限变更结果尚未确认；请核对当前权限，不会自动重发。')), timeoutMs);
+        finish = result => {
+          if (settled) return;
+          settled = true;
+          clearTimeout(timer);
+          this.permissionWaiters.delete(threadId);
+          resolve(result);
+        };
+      });
+      this.permissionWaiters.set(threadId, { mode, finish });
+      return { promise, cancel: () => finish(null) };
+    }
+    clear() {
+      for (const waiter of this.permissionWaiters.values()) waiter.finish(new Error('连接已断开，权限变更结果尚未确认；不会自动重发。'));
+      super.clear();
+    }
+  }
+  async function updatePermissions(request, contexts, notifications, optionsCache, threadId, mode) {
+    if (!Object.hasOwn(permissionPresets, mode)) throw new Error('不支持的权限模式');
+    if (notifications.permissionWaiters.has(threadId)) throw new Error('该对话的权限变更正在等待内核确认');
+    const context = contexts.get(threadId);
+    if (!context) throw new Error('请先打开对话');
+    await optionsCache.read(request, threadId, context);
+    if (!contexts.has(threadId)) throw new Error('连接已变化，请重新打开对话后设置权限');
+    if (!optionsCache.context(threadId, contexts.get(threadId)).permissionModes.includes(mode)) throw new Error('此主机或项目配置不支持该权限模式');
+    if (contexts.get(threadId).permissionMode === mode) return optionsCache.context(threadId, contexts.get(threadId));
+    const waiting = notifications.waitForPermission(threadId, mode);
+    try {
+      await request('thread/settings/update', { threadId, ...permissionPresets[mode] });
+      // An empty RPC response only acknowledges queuing. Never invent applied settings.
+      const result = await waiting.promise;
+      if (result instanceof Error) throw result;
+      if (!contexts.has(threadId)) throw new Error('连接已变化，权限变更结果尚未确认');
+    } finally { waiting.cancel(); }
+    return optionsCache.context(threadId, contexts.get(threadId));
+  }
+  async function createThread(request, target, input, settings, additionalContext, onThreadCreated = () => {}) {
+    let permissions;
+    try { permissions = await globalPermissionOverrides(request, { cwd: target.cwd, model: settings.model, desktopPermissionMode: settings.desktopPermissionMode }); }
+    catch (error) { error.deliveryUnknown = false; throw error; }
+    target = { ...target, ...permissions };
+    let response;
+    try { response = await request('thread/start', target); }
+    catch (error) {
+      if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(result => startFirstTurn(result.thread))
+        .catch(lateError => { if (lateError.deliveryResult) return lateError.deliveryResult; throw lateError; });
+      throw error;
+    }
+    return startFirstTurn(response.thread);
+    async function startFirstTurn(thread) {
+      onThreadCreated(thread.id);
+      const result = started => ({ threadId:thread.id, turnId:started?.turn?.id || null });
+      try {
+        const started = await request('turn/start', { threadId:thread.id, input,
+          ...permissions,
+          ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput),
+          ...(additionalContext ? { additionalContext: { ...additionalContext,
+            ...mobileTurnSource(settings.clientUserMessageId, settings.containsVoiceInput).additionalContext } } : {}),
+          ...(settings.clientUserMessageId ? { clientUserMessageId:settings.clientUserMessageId } : {}),
+          ...(settings.model ? { model:settings.model } : {}),
+          ...(settings.thinking ? { effort:settings.thinking } : {}),
+          ...(settings.serviceTier !== undefined ? { serviceTier:settings.serviceTier } : {}) });
+        return result(started);
+      } catch (error) {
+        // The known thread and the late first turn together form one creation receipt.
+        if (error.deliveryResult) error.deliveryResult = error.deliveryResult.then(result, lateError => {
+          // The thread already exists even if its first turn was rejected.
+          throw Object.assign(new Error(lateError.message || '新对话首条消息未确认'), { cause: lateError, deliveryUnknown: true });
+        });
+        throw error;
+      }
+    }
+  }
+  function projectThreadTarget(project) {
+    const roots = project.roots.map(root => root.path);
+    return { projectId: project.id || project.projectId, runtimeWorkspaceRoots: roots,
+      ...(roots.length ? { cwd: roots[0] } : {}) };
+  }
+  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' && !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, containsVoiceInput = false) {
+    try {
+      const { thread } = await request('thread/read', { threadId, includeTurns: false });
+      const permissions = await globalPermissionOverrides(request, thread, threadId);
+      if (Object.keys(permissions).length) await request('thread/settings/update', { threadId, ...permissions });
+    } catch (error) { error.deliveryUnknown = false; throw error; }
+    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) {
+    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') {
-        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, compactItem, compactTurn, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, projectlessThreadTarget, updateSettings,
-    permissionState, availablePermissionModes, PermissionOptionsCache, updatePermissions };
-});
+        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('引导已提交，但原排队消息未删除，请检查队列，勿重复引导');
+      } else {
+        await request('thread/queue/start', { threadId, queuedSubmissionId });
+      }
+    } else {
+      await request(`thread/queue/${action}`, { threadId, queuedSubmissionId });
+    }
+    return readQueue(request, threadId);
+  }
+  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, parseCodexDelegation, toolDelegation, projectThreadTarget, createThread, readQueue, addQueue, changeQueue, compactItem, compactTurn, beginSnapshot, mergeItems, applyNotification, mergeUsage, UsageCache, readProjects, orderDesktopProjects, threadProjectId, catalogThreadProjectId, projectlessThreadTarget, updateSettings,
+    permissionState, availablePermissionModes, PermissionOptionsCache, SettingsNotifications, updatePermissions,
+    readGlobalPermissions, writeGlobalPermissions, globalPermissionOverrides, mobileTurnSource };
+});