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

package/dist/src/shared-thread-stream.mjs

@@ -1,80 +1,164 @@
 // Event-driven subscription adapter. Normal desktop-tool polling remains in its own adapter.
-import timelineSync from '../shared/timeline-sync.cjs';
-const threadListNotificationMethods = new Set([
-  'thread/started', 'thread/status/changed', 'thread/name/updated',
-  'thread/archived', 'thread/unarchived', 'thread/deleted',
-  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
-]);
-export async function streamSharedThread(response, threadId, client, normalize, requestedSync, known) {
+import timelineSync from '../shared/timeline-sync.cjs';
+export const threadListNotificationMethods = new Set([
+  'thread/started', 'thread/status/changed', 'thread/name/updated',
+  'thread/archived', 'thread/unarchived', 'thread/deleted',
+  'thread/project/updated', 'project/changed', 'turn/started', 'turn/completed',
+]);
+export async function streamSharedThread(response, threadId, client, normalize, requestedSync) {
   response.startEvents();
-  let closed = false, timer, subscription, streamReady = false;
+  let closed = false, timer, subscription, releaseActivity, streamReady = false, flushing = false;
+  let tracePending = false, pendingReset;
   const pending = new Map(), sentTurns = new Map();
   let fromSeq, toSeq, syncId = requestedSync?.id, epoch = requestedSync?.epoch;
   let finish;
   const done = new Promise(resolve => { finish = resolve; });
-  const emit = (name, value) => { if (!closed) response.event(name, value); };
-  const flush = () => {
+  const emit = (name, value) => { if (!closed) return response.event(name, value); };
+  let historySync;
+  const publishHistorySync = () => {
+    if (typeof client.isHistorySyncing !== 'function') return;
+    const active = client.isHistorySyncing(threadId);
+    // End the notice only after the recovered body has been delivered, not
+    // when the upstream read finishes while its update is still being flushed.
+    if (!active && (!streamReady || flushing || pendingReset || pending.size)) return;
+    if (historySync === active) return;
+    historySync = active;
+    emit('history-sync', { threadId, active });
+  };
+  const flush = async () => {
     clearTimeout(timer); timer = null;
     const record = client.threads.get(threadId);
-    if (!streamReady || !record || !pending.size) return;
-    const base = normalize({ thread: { ...record.thread, turns: [] }, sync: { id: syncId, epoch, fromSeq, toSeq } });
-    const turns = [], turnPatches = [];
-    for (const turn of pending.values()) {
-      const normalized = normalize({ thread: { ...record.thread, turns: [turn] } }).turns[0];
-      const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
-      if (patch) turnPatches.push(patch); else turns.push(normalized);
-      sentTurns.set(turn.id, normalized);
+    if (closed || flushing || !streamReady || !record || (!pendingReset && !pending.size)) return;
+    flushing = true;
+    try {
+      if (pendingReset) {
+        const snapshot = pendingReset;
+        pendingReset = undefined;
+        for (const [id, change] of pending) if (change.sequence <= snapshot.sync.seq) pending.delete(id);
+        fromSeq = pending.size ? Math.max(fromSeq, snapshot.sync.seq + 1) : undefined;
+        if (!pending.size) toSeq = undefined;
+        tracePending = [...pending.values()].some(change => change.immediate);
+        const normalized = await normalize(snapshot);
+        if (closed) return;
+        await emit('update', normalized);
+        syncId = normalized.sync.id; epoch = normalized.sync.epoch;
+        sentTurns.clear();
+        for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
+        client.traceSync?.('stream-reset-sent', threadId, { seq: normalized.sync.seq,
+          turnOrder: normalized.turns.map(turn => turn.id) });
+        return;
+      }
+      const batch = structuredClone([...pending.values()].map(change => change.turn));
+      const thread = { ...record.thread, turns: [] }, sync = { id: syncId, epoch, fromSeq, toSeq };
+      const turnOrder = record.thread.turns.map(turn => turn.id), retained = new Set(turnOrder);
+      const trace = tracePending;
+      pending.clear(); fromSeq = toSeq = undefined; tracePending = false;
+      const base = await normalize({ thread, sync });
+      const turns = [], turnPatches = [];
+      const normalizedTurns = [];
+      for (const turn of batch) {
+        if (turn.cacheStub) continue;
+        const normalized = (await normalize({ thread: { ...thread, turns: [turn] } })).turns[0];
+        const patch = timelineSync.diffTurn(sentTurns.get(turn.id), normalized);
+        if (patch) turnPatches.push(patch); else turns.push(normalized);
+        normalizedTurns.push(normalized);
+      }
+      if (closed) return;
+      await emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
+      for (const turn of normalizedTurns) sentTurns.set(turn.id, turn);
+      for (const id of sentTurns.keys()) if (!retained.has(id)) sentTurns.delete(id);
+      if (trace || turns.length || (base.sync.fromSeq <= record.recoverAfter && record.recoverAfter <= base.sync.toSeq)) {
+        client.traceSync?.('stream-update-sent', threadId, { closed, fromSeq: base.sync?.fromSeq, toSeq: base.sync?.toSeq, turnOrder,
+        messages: turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])),
+        patches: turnPatches.map(patch => ({ turnId: patch.id, entries: (patch.entries || []).map(entry => entry.id), appended: (patch.appended || []).map(entry => entry.id) })) });
+      }
+    } catch (error) { emit('bridge-error', { error: error.message }); response.end(); finish(); }
+    finally {
+      flushing = false;
+      publishHistorySync();
+      if (!closed && (pendingReset || pending.size) && !timer) timer = setTimeout(flush, 0);
     }
-    emit('update', { ...base, turns, ...(turnPatches.length ? { turnPatches } : {}) });
-    pending.clear();
-    fromSeq = toSeq = undefined;
   };
   const onTurn = ({ thread, turn, sequence, immediate }) => {
     if (thread.id !== threadId) return;
     if (!fromSeq) fromSeq = sequence;
     toSeq = sequence;
-    pending.set(turn.id, turn);
+    pending.set(turn.id, { turn, sequence, immediate: immediate || pending.get(turn.id)?.immediate });
+    if (immediate) tracePending = true;
     if (immediate) flush(); else if (!timer) timer = setTimeout(flush, 50);
   };
-  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
-  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
-  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
-  const onNotification = ({ method, params }) => {
-    if (!threadListNotificationMethods.has(method)) return;
-    emit('thread-list-changed', { method, threadId: params.threadId || params.thread?.id || '' });
-  };
-  const onDisconnected = () => { emit('bridge-error', { error: '完整控制已断开，请重新连接。' }); response.end(); finish(); };
+  const onReset = snapshot => {
+    if (snapshot.thread.id !== threadId) return;
+    pendingReset = structuredClone(snapshot);
+    pendingReset.sync.reset = true;
+    flush();
+  };
+  const onSettings = id => { if (id === threadId) emit('settings', client.context(id)); };
+  const onRequests = id => { if (id === threadId) emit('approvals', { requests: client.serverRequests.list(threadId) }); };
+  const onQueue = id => { if (id === threadId) emit('queue-changed', {}); };
+  const onDisconnected = () => { emit('bridge-error', { error: 'Codex 内核连接已断开，请重新连接。' }); response.end(); finish(); };
+  const onInvalidated = id => { if (id === threadId) emit('history-invalidated', {}); };
+  const onHistorySync = id => { if (id === threadId) publishHistorySync(); };
+  const onChatError = value => { if (value.threadId === threadId) emit('chat-error', value); };
   response.once('close', () => { closed = true; finish(); });
-  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
-  client.on('queue-changed', onQueue);
-  client.on('requests-changed', onRequests);
-  client.on('notification', onNotification);
+  client.on('turn', onTurn); client.on('settings', onSettings); client.on('disconnected', onDisconnected);
+  client.on('timeline-reset', onReset);
+  client.on('queue-changed', onQueue);
+  client.on('requests-changed', onRequests);
+  client.on('history-invalidated', onInvalidated);
+  client.on('history-sync', onHistorySync);
+  client.on('chat-error', onChatError);
+  publishHistorySync();
   try {
-    subscription = await client.acquire(threadId, requestedSync);
-    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
-    streamReady = true;
-    if (!closed) {
-      const normalized = normalize(subscription.record);
-      const latest = normalized.turns.at(-1);
-      const unchanged = subscription.snapshot && known?.turnId && known.turnId === latest?.id
-        && known.updatedAt > 0 && known.updatedAt === Number(normalized.thread.updatedAt)
-        && normalized.thread.status === 'idle' && latest?.status !== 'inProgress'
-        && known.turnStatus && known.turnStatus !== 'inProgress';
-      if (subscription.snapshot) emit('update', unchanged ? { ...normalized, turns: [], notModified: true } : normalized);
-      else if (subscription.catchup) emit('update', normalize(subscription.catchup));
-      for (const turn of normalized.turns) sentTurns.set(turn.id, turn);
+    const started = performance.now();
+    client.traceSync?.('stream-open', threadId, { requestedSeq: requestedSync?.after });
+    subscription = await client.acquire(threadId, requestedSync);
+    syncId = subscription.record.sync.id; epoch = subscription.record.sync.epoch;
+    if (!closed) {
+      const initial = structuredClone(subscription.record), catchup = subscription.catchup && structuredClone(subscription.catchup);
+      if (pendingReset?.sync.seq <= initial.sync.seq) pendingReset = undefined;
+      // Only discard notifications certified by the acquired snapshot/catchup.
+      for (const [id, change] of pending) if (change.sequence <= initial.sync.seq) pending.delete(id);
+      fromSeq = pending.size ? Math.max(fromSeq, initial.sync.seq + 1) : undefined;
+      if (!pending.size) toSeq = undefined;
+      tracePending = [...pending.values()].some(change => change.immediate);
+      const normalized = await normalize(subscription.confirmed ? { ...initial, thread: { ...initial.thread, turns: [] } } : initial);
+      const delivered = subscription.snapshot ? normalized : catchup ? await normalize(catchup) : null;
+      const sent = Boolean(delivered) && !closed;
+      if (sent) await emit('update', delivered);
+      // A timestamp-confirmed cache only needs the new subscription boundary,
+      // never an empty replacement window or a repeated body snapshot.
+      if (subscription.confirmed && !closed) await emit('sync-ready', {
+        thread: normalized.thread, sync: normalized.sync,
+      });
+      client.traceSync?.('stream-initial-sent', threadId, { ms: Math.round(performance.now() - started), closed,
+        snapshot: subscription.snapshot, catchup: Boolean(catchup), sent, seq: normalized.sync?.seq,
+        deliveredSync: sent ? delivered.sync : undefined,
+        messages: sent ? delivered.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) : [],
+        windowMessages: normalized.turns.flatMap(turn => turn.entries.map(entry => [turn.id, entry.id])) });
+      for (const turn of normalized.turns) if (!turn.cacheStub) sentTurns.set(turn.id, turn);
       emit('queue-changed', {});
       onRequests(threadId);
+      streamReady = true;
+      publishHistorySync();
+      if (!closed && typeof client.acquireActivity === 'function') {
+        releaseActivity = client.acquireActivity(threadId, value => emit('dots-activity', value));
+      }
       flush();
     }
     await done;
   } catch (error) { emit('bridge-error', { error: error.message }); response.end(); }
   finally {
+    client.traceSync?.('stream-close', threadId, { ready: streamReady });
     clearTimeout(timer);
-    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
-    client.off('queue-changed', onQueue);
-    client.off('requests-changed', onRequests);
-    client.off('notification', onNotification);
+    releaseActivity?.();
+    client.off('turn', onTurn); client.off('settings', onSettings); client.off('disconnected', onDisconnected);
+    client.off('timeline-reset', onReset);
+    client.off('queue-changed', onQueue);
+    client.off('requests-changed', onRequests);
+    client.off('history-invalidated', onInvalidated);
+    client.off('history-sync', onHistorySync);
+    client.off('chat-error', onChatError);
     if (subscription) await subscription.release();
   }
 }

package/dist/src/skill-install.mjs

@@ -1,64 +1,51 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { createHash } from 'node:crypto';
-import { readRecord, writeRecord } from './service-lifecycle.mjs';
-
-const owner = '@walkhi/code-relax';
-const markerName = '.code-relax-install.json';
-const legacyOwner = '@closedhi/codex-remote';
-const legacyMarkerName = '.codex-remote-install.json';
-const digest = value => createHash('sha256').update(value).digest('hex');
-export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
-const legacySkillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/codex-remote');
-
-// Refuse junctions/symlinks along managed paths before writing or removing files.
-export function assertPlainPath(target) {
-  for (let item = path.resolve(target); ; item = path.dirname(item)) {
-    try { if (fs.lstatSync(item).isSymbolicLink()) throw new Error(`不自动修改链接路径：${item}`); }
-    catch (error) { if (error.code !== 'ENOENT') throw error; }
-    if (path.dirname(item) === item) break;
-  }
-}
-
-export function inspectSkill(target = skillDirectory()) {
-  assertPlainPath(target);
-  if (!fs.existsSync(target)) return { installed: false, managed: false, target };
-  const markerPath = path.join(target, markerName), file = path.join(target, 'SKILL.md');
-  assertPlainPath(markerPath); assertPlainPath(file);
-  const marker = readRecord(markerPath);
-  const managed = marker?.owner === owner && fs.existsSync(file)
-    && marker.sha256 === digest(fs.readFileSync(file))
-    && fs.readdirSync(target).every(name => ['SKILL.md', markerName].includes(name));
-  return { installed: true, managed, target };
-}
-
-export function removeLegacyManagedSkill(target = legacySkillDirectory()) {
-  const marker = readRecord(path.join(target, legacyMarkerName));
-  const file = path.join(target, 'SKILL.md');
-  if (marker?.owner !== legacyOwner || !fs.existsSync(file) || marker.sha256 !== digest(fs.readFileSync(file))
-    || !fs.readdirSync(target).every(name => ['SKILL.md', legacyMarkerName].includes(name))) return false;
-  fs.unlinkSync(file); fs.unlinkSync(path.join(target, legacyMarkerName)); fs.rmdirSync(target);
-  return true;
-}
-
-export function installSkill(source, target = skillDirectory()) {
-  const state = inspectSkill(target);
-  if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
-  const content = fs.readFileSync(source);
-  fs.mkdirSync(target, { recursive: true });
-  fs.writeFileSync(path.join(target, 'SKILL.md'), content);
-  writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
-  if (path.resolve(target) === path.resolve(skillDirectory())) removeLegacyManagedSkill();
-  return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
-}
-
-export function removeSkill(target = skillDirectory()) {
-  const state = inspectSkill(target);
-  if (!state.installed) return { removed: false, target, message: 'Skill 未安装。' };
-  if (!state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，未删除：${target}`);
-  fs.unlinkSync(path.join(target, 'SKILL.md'));
-  fs.unlinkSync(path.join(target, markerName));
-  fs.rmdirSync(target);
-  return { removed: true, target, message: '已移除本包安装的 Skill。' };
-}
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { createHash } from 'node:crypto';
+import { readRecord, writeRecord } from './service-lifecycle.mjs';
+
+const owner = '@walkhi/code-relax';
+const markerName = '.code-relax-install.json';
+const digest = value => createHash('sha256').update(value).digest('hex');
+export const skillDirectory = (home = os.homedir()) => path.join(home, '.agents/skills/code-relax');
+
+// Refuse junctions/symlinks along managed paths before writing or removing files.
+export function assertPlainPath(target) {
+  for (let item = path.resolve(target); ; item = path.dirname(item)) {
+    try { if (fs.lstatSync(item).isSymbolicLink()) throw new Error(`不自动修改链接路径：${item}`); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (path.dirname(item) === item) break;
+  }
+}
+
+export function inspectSkill(target = skillDirectory()) {
+  assertPlainPath(target);
+  if (!fs.existsSync(target)) return { installed: false, managed: false, target };
+  const markerPath = path.join(target, markerName), file = path.join(target, 'SKILL.md');
+  assertPlainPath(markerPath); assertPlainPath(file);
+  const marker = readRecord(markerPath);
+  const managed = marker?.owner === owner && fs.existsSync(file)
+    && marker.sha256 === digest(fs.readFileSync(file))
+    && fs.readdirSync(target).every(name => ['SKILL.md', markerName].includes(name));
+  return { installed: true, managed, target };
+}
+
+export function installSkill(source, target = skillDirectory()) {
+  const state = inspectSkill(target);
+  if (state.installed && !state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，请保留并手动处理：${target}`);
+  const content = fs.readFileSync(source);
+  fs.mkdirSync(target, { recursive: true });
+  fs.writeFileSync(path.join(target, 'SKILL.md'), content);
+  writeRecord(path.join(target, markerName), { owner, sha256: digest(content) });
+  return { installed: true, target, message: 'Skill 已安装/更新；若 Codex 尚未显示，请重新打开 Codex。' };
+}
+
+export function removeSkill(target = skillDirectory()) {
+  const state = inspectSkill(target);
+  if (!state.installed) return { removed: false, target, message: 'Skill 未安装。' };
+  if (!state.managed) throw new Error(`同名 Skill 非本包管理或已被修改，未删除：${target}`);
+  fs.unlinkSync(path.join(target, 'SKILL.md'));
+  fs.unlinkSync(path.join(target, markerName));
+  fs.rmdirSync(target);
+  return { removed: true, target, message: '已移除本包安装的 Skill。' };
+}

package/dist/src/thread-title-generation.mjs

@@ -1,150 +1,150 @@
-import { randomUUID } from 'node:crypto';
-
-const TITLE_MODEL = 'gpt-5.6-luna';
-const TITLE_TIMEOUT_MS = 30_000;
-const TITLE_SCHEMA = Object.freeze({
-  type: 'object',
-  properties: {
-    title: { type: 'string', minLength: 1, maxLength: 36 },
-    description: { type: 'string', minLength: 1, maxLength: 100 },
-  },
-  required: ['title', 'description'],
-  additionalProperties: false,
-});
-
-function titlePrompt(prompt) {
-  return [
-    'You are a helpful assistant. You will be presented with a user prompt, and your job is to provide a short title for a task that will be created from that prompt.',
-    'The title will be shown in the UI to represent the prompt.',
-    'Generate a concise UI title of at most 36 characters and fill the structured title field with plain text.',
-    'Fill the structured description field with a compact, search-oriented summary of at most 100 characters.',
-    'Write both values in the user\'s locale. Do not include quotes, markdown, formatting characters, or trailing punctuation.',
-    'Capture the question or core change requested instead of copying the whole prompt.',
-    'Do not respond to the user or attempt to solve the problem; only fill the structured fields.',
-    '',
-    'User prompt:',
-    prompt,
-  ].join('\n');
-}
-
-function normalizeTitle(value) {
-  let title = String(value || '').replace(/\r\n/g, '\n').split('\n').find(line => line.trim())?.trim() || '';
-  title = title.replace(/^title[:\s]+/i, '');
-  title = title.replace(/^[`"'“”‘’]+|[`"'“”‘’]+$/g, '');
-  title = title.replace(/\s+/g, ' ').replace(/[.?!。？！]+$/, '').trim();
-  if (!title) return null;
-  if (title.length <= 36) return title;
-  let end = 36;
-  if (title[end] !== ' ' && title[end - 1] !== ' ') {
-    const nextSpace = title.indexOf(' ', end);
-    end = nextSpace < 0 ? title.length : nextSpace;
-  }
-  const head = title.slice(0, end).trimEnd();
-  return title.slice(end).trim() ? `${head}…` : head;
-}
-
-function parseStructuredTitle(text) {
-  if (!text?.trim()) return null;
-  try {
-    const value = JSON.parse(text.trim());
-    return normalizeTitle(value?.title);
-  } catch {
-    return null;
-  }
-}
-
-export async function generateThreadTitle({ request, subscribe, prompt, cwd = null,
-  timeoutMs = TITLE_TIMEOUT_MS, uuid = randomUUID }) {
-  const source = String(prompt || '').trim();
-  if (!source) return null;
-  const { thread } = await request('thread/start', {
-    model: TITLE_MODEL,
-    modelProvider: null,
-    allowProviderModelFallback: true,
-    cwd,
-    approvalPolicy: 'never',
-    permissions: ':read-only',
-    runtimeWorkspaceRoots: [],
-    config: {
-      'features.enable_fanout': false,
-      'features.hooks': false,
-      'features.multi_agent': false,
-      'features.multi_agent_v2': false,
-      'features.plugins': false,
-      'features.shell_snapshot': false,
-      'features.tool_suggest': false,
-      'features.apps': false,
-      'mcp_servers.codex_app': { enabled: false, command: '' },
-      apps: { _default: { enabled: false, destructive_enabled: false, open_world_enabled: false } },
-      model_reasoning_effort: 'low',
-      web_search: 'disabled',
-    },
-    personality: null,
-    ephemeral: true,
-    threadSource: 'thread_title',
-    experimentalRawEvents: false,
-    dynamicTools: null,
-    serviceTier: null,
-  });
-  const threadId = thread.id;
-  let message = '';
-  let turnId = null;
-  let stop = () => {};
-  try {
-    const completed = new Promise((resolve, reject) => {
-      const timer = setTimeout(() => reject(new Error('生成对话标题超时。')), timeoutMs);
-      timer.unref?.();
-      const unsubscribe = subscribe(({ method, params }) => {
-        if (params.threadId !== threadId) return;
-        if (method === 'turn/started') turnId = params.turn?.id || turnId;
-        if (turnId && params.turnId && params.turnId !== turnId) return;
-        if (method === 'item/agentMessage/delta') message += params.delta || '';
-        if (method === 'item/completed' && params.item?.type === 'agentMessage') message = params.item.text || message;
-        if (method === 'error') {
-          clearTimeout(timer);
-          reject(new Error(params.error?.message || '生成对话标题失败。'));
-        }
-        if (method === 'turn/completed') {
-          clearTimeout(timer);
-          if (params.turn?.status !== 'completed') {
-            reject(new Error(params.turn?.error?.message || `生成对话标题失败：${params.turn?.status || 'unknown'}`));
-          } else resolve(parseStructuredTitle(message));
-        }
-      });
-      stop = () => { clearTimeout(timer); unsubscribe(); };
-    });
-    const started = await request('turn/start', {
-      threadId,
-      turnTrigger: 'thread_title',
-      clientUserMessageId: uuid(),
-      input: [{ type: 'text', text: titlePrompt(source), text_elements: [] }],
-      cwd: null,
-      approvalPolicy: null,
-      permissions: ':read-only',
-      runtimeWorkspaceRoots: [],
-      model: null,
-      effort: null,
-      serviceTier: null,
-      personality: null,
-      outputSchema: TITLE_SCHEMA,
-      collaborationMode: null,
-    });
-    turnId ||= started.turn?.id || null;
-    return await completed;
-  } finally {
-    stop();
-    await request('thread/unsubscribe', { threadId }).catch(() => {});
-  }
-}
-
-export async function generateAndSetThreadTitle({ request, subscribe, threadId, prompt, cwd = null,
-  timeoutMs, uuid }) {
-  const title = await generateThreadTitle({ request, subscribe, prompt, cwd, timeoutMs, uuid });
-  if (!title) return null;
-  const current = await request('thread/read', { threadId, includeTurns: false });
-  if (current.thread?.name?.trim()) return null;
-  await request('thread/name/set', { threadId, name: title });
-  return title;
-}
-
-export const threadTitleInternals = { normalizeTitle, parseStructuredTitle, TITLE_SCHEMA, TITLE_MODEL };
+import { randomUUID } from 'node:crypto';
+
+const TITLE_MODEL = 'gpt-5.6-luna';
+const TITLE_TIMEOUT_MS = 30_000;
+const TITLE_SCHEMA = Object.freeze({
+  type: 'object',
+  properties: {
+    title: { type: 'string', minLength: 1, maxLength: 36 },
+    description: { type: 'string', minLength: 1, maxLength: 100 },
+  },
+  required: ['title', 'description'],
+  additionalProperties: false,
+});
+
+function titlePrompt(prompt) {
+  return [
+    'You are a helpful assistant. You will be presented with a user prompt, and your job is to provide a short title for a task that will be created from that prompt.',
+    'The title will be shown in the UI to represent the prompt.',
+    'Generate a concise UI title of at most 36 characters and fill the structured title field with plain text.',
+    'Fill the structured description field with a compact, search-oriented summary of at most 100 characters.',
+    'Write both values in the user\'s locale. Do not include quotes, markdown, formatting characters, or trailing punctuation.',
+    'Capture the question or core change requested instead of copying the whole prompt.',
+    'Do not respond to the user or attempt to solve the problem; only fill the structured fields.',
+    '',
+    'User prompt:',
+    prompt,
+  ].join('\n');
+}
+
+function normalizeTitle(value) {
+  let title = String(value || '').replace(/\r\n/g, '\n').split('\n').find(line => line.trim())?.trim() || '';
+  title = title.replace(/^title[:\s]+/i, '');
+  title = title.replace(/^[`"'“”‘’]+|[`"'“”‘’]+$/g, '');
+  title = title.replace(/\s+/g, ' ').replace(/[.?!。？！]+$/, '').trim();
+  if (!title) return null;
+  if (title.length <= 36) return title;
+  let end = 36;
+  if (title[end] !== ' ' && title[end - 1] !== ' ') {
+    const nextSpace = title.indexOf(' ', end);
+    end = nextSpace < 0 ? title.length : nextSpace;
+  }
+  const head = title.slice(0, end).trimEnd();
+  return title.slice(end).trim() ? `${head}…` : head;
+}
+
+function parseStructuredTitle(text) {
+  if (!text?.trim()) return null;
+  try {
+    const value = JSON.parse(text.trim());
+    return normalizeTitle(value?.title);
+  } catch {
+    return null;
+  }
+}
+
+export async function generateThreadTitle({ request, subscribe, prompt, cwd = null,
+  timeoutMs = TITLE_TIMEOUT_MS, uuid = randomUUID }) {
+  const source = String(prompt || '').trim();
+  if (!source) return null;
+  const { thread } = await request('thread/start', {
+    model: TITLE_MODEL,
+    modelProvider: null,
+    allowProviderModelFallback: true,
+    cwd,
+    approvalPolicy: 'never',
+    permissions: ':read-only',
+    runtimeWorkspaceRoots: [],
+    config: {
+      'features.enable_fanout': false,
+      'features.hooks': false,
+      'features.multi_agent': false,
+      'features.multi_agent_v2': false,
+      'features.plugins': false,
+      'features.shell_snapshot': false,
+      'features.tool_suggest': false,
+      'features.apps': false,
+      'mcp_servers.codex_app': { enabled: false, command: '' },
+      apps: { _default: { enabled: false, destructive_enabled: false, open_world_enabled: false } },
+      model_reasoning_effort: 'low',
+      web_search: 'disabled',
+    },
+    personality: null,
+    ephemeral: true,
+    threadSource: 'thread_title',
+    experimentalRawEvents: false,
+    dynamicTools: null,
+    serviceTier: null,
+  });
+  const threadId = thread.id;
+  let message = '';
+  let turnId = null;
+  let stop = () => {};
+  try {
+    const completed = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('生成对话标题超时。')), timeoutMs);
+      timer.unref?.();
+      const unsubscribe = subscribe(({ method, params }) => {
+        if (params.threadId !== threadId) return;
+        if (method === 'turn/started') turnId = params.turn?.id || turnId;
+        if (turnId && params.turnId && params.turnId !== turnId) return;
+        if (method === 'item/agentMessage/delta') message += params.delta || '';
+        if (method === 'item/completed' && params.item?.type === 'agentMessage') message = params.item.text || message;
+        if (method === 'error') {
+          clearTimeout(timer);
+          reject(new Error(params.error?.message || '生成对话标题失败。'));
+        }
+        if (method === 'turn/completed') {
+          clearTimeout(timer);
+          if (params.turn?.status !== 'completed') {
+            reject(new Error(params.turn?.error?.message || `生成对话标题失败：${params.turn?.status || 'unknown'}`));
+          } else resolve(parseStructuredTitle(message));
+        }
+      });
+      stop = () => { clearTimeout(timer); unsubscribe(); };
+    });
+    const started = await request('turn/start', {
+      threadId,
+      turnTrigger: 'thread_title',
+      clientUserMessageId: uuid(),
+      input: [{ type: 'text', text: titlePrompt(source), text_elements: [] }],
+      cwd: null,
+      approvalPolicy: null,
+      permissions: ':read-only',
+      runtimeWorkspaceRoots: [],
+      model: null,
+      effort: null,
+      serviceTier: null,
+      personality: null,
+      outputSchema: TITLE_SCHEMA,
+      collaborationMode: null,
+    });
+    turnId ||= started.turn?.id || null;
+    return await completed;
+  } finally {
+    stop();
+    await request('thread/unsubscribe', { threadId }).catch(() => {});
+  }
+}
+
+export async function generateAndSetThreadTitle({ request, subscribe, threadId, prompt, cwd = null,
+  timeoutMs, uuid }) {
+  const title = await generateThreadTitle({ request, subscribe, prompt, cwd, timeoutMs, uuid });
+  if (!title) return null;
+  const current = await request('thread/read', { threadId, includeTurns: false });
+  if (current.thread?.name?.trim()) return null;
+  await request('thread/name/set', { threadId, name: title });
+  return title;
+}
+
+export const threadTitleInternals = { normalizeTitle, parseStructuredTitle, TITLE_SCHEMA, TITLE_MODEL };