codexmate 0.0.17 → 0.0.19

package/cli.js

@@ -38,6 +38,7 @@ const {
     writeJsonAtomic,
     formatTimestampForFileName
 } = require('./lib/cli-file-utils');
+const { buildLineDiff } = require('./lib/text-diff');
 const {
     extractModelNames,
     hasModelsListPayload,
@@ -63,7 +64,8 @@ const {
 } = require('./lib/workflow-engine');
 
 const DEFAULT_WEB_PORT = 3737;
-const DEFAULT_WEB_HOST = '127.0.0.1';
+const DEFAULT_WEB_HOST = '0.0.0.0';
+const DEFAULT_WEB_OPEN_HOST = '127.0.0.1';
 
 // ============================================================================
 // 配置
@@ -78,6 +80,9 @@ const CURRENT_MODELS_FILE = path.join(CONFIG_DIR, 'provider-current-models.json'
 const INIT_MARK_FILE = path.join(CONFIG_DIR, 'codexmate-init.json');
 const BUILTIN_PROXY_SETTINGS_FILE = path.join(CONFIG_DIR, 'codexmate-proxy.json');
 const CODEX_SESSIONS_DIR = path.join(CONFIG_DIR, 'sessions');
+const SESSION_TRASH_DIR = path.join(CONFIG_DIR, 'codexmate-session-trash');
+const SESSION_TRASH_FILES_DIR = path.join(SESSION_TRASH_DIR, 'files');
+const SESSION_TRASH_INDEX_FILE = path.join(SESSION_TRASH_DIR, 'index.json');
 const OPENCLAW_DIR = path.join(os.homedir(), '.openclaw');
 const OPENCLAW_CONFIG_FILE = path.join(OPENCLAW_DIR, 'openclaw.json');
 const OPENCLAW_WORKSPACE_DIR = path.join(OPENCLAW_DIR, 'workspace');
@@ -94,6 +99,7 @@ const DEFAULT_MODELS = ['gpt-5.3-codex', 'gpt-5.1-codex-max', 'gpt-4-turbo', 'gp
 const SPEED_TEST_TIMEOUT_MS = 8000;
 const HEALTH_CHECK_TIMEOUT_MS = 6000;
 const MAX_SESSION_LIST_SIZE = 300;
+const MAX_SESSION_TRASH_LIST_SIZE = 500;
 const MAX_EXPORT_MESSAGES = 1000;
 const DEFAULT_SESSION_DETAIL_MESSAGES = 300;
 const MAX_SESSION_DETAIL_MESSAGES = 1000;
@@ -102,6 +108,7 @@ const CODEXMATE_MANAGED_MARKER = '# codexmate-managed: true';
 const SESSION_LIST_CACHE_TTL_MS = 4000;
 const SESSION_SUMMARY_READ_BYTES = 256 * 1024;
 const SESSION_CONTENT_READ_BYTES = SESSION_SUMMARY_READ_BYTES;
+const EXACT_MESSAGE_COUNT_CACHE_MAX_ENTRIES = 800;
 const DEFAULT_CONTENT_SCAN_LIMIT = 50;
 const SESSION_SCAN_FACTOR = 4;
 const SESSION_SCAN_MIN_FILES = 800;
@@ -110,9 +117,13 @@ const AGENTS_FILE_NAME = 'AGENTS.md';
 const CODEX_SKILLS_DIR = path.join(CONFIG_DIR, 'skills');
 const CLAUDE_SKILLS_DIR = path.join(CLAUDE_DIR, 'skills');
 const AGENTS_SKILLS_DIR = path.join(os.homedir(), '.agents', 'skills');
+const SKILL_TARGETS = Object.freeze([
+    Object.freeze({ app: 'codex', label: 'Codex', dir: getCodexSkillsDir() }),
+    Object.freeze({ app: 'claude', label: 'Claude Code', dir: getClaudeSkillsDir() })
+]);
 const SKILL_IMPORT_SOURCES = Object.freeze([
-    { app: 'claude', label: 'Claude Code', dir: CLAUDE_SKILLS_DIR },
-    { app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR }
+    ...SKILL_TARGETS,
+    Object.freeze({ app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR })
 ]);
 const MODELS_CACHE_TTL_MS = 60 * 1000;
 const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
@@ -121,6 +132,7 @@ const MODELS_RESPONSE_MAX_BYTES = 1024 * 1024;
 const MAX_RECENT_CONFIGS = 3;
 const MAX_UPLOAD_SIZE = 200 * 1024 * 1024;
 const MAX_SKILLS_ZIP_UPLOAD_SIZE = 20 * 1024 * 1024;
+const MAX_API_BODY_SIZE = 4 * 1024 * 1024;
 const MAX_SKILLS_ZIP_ENTRY_COUNT = 2000;
 const MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
 const DEFAULT_EXTRACT_SUFFIXES = Object.freeze(['.json']);
@@ -160,6 +172,38 @@ const CLI_INSTALL_TARGETS = Object.freeze([
 const HTTP_KEEP_ALIVE_AGENT = new http.Agent({ keepAlive: true });
 const HTTPS_KEEP_ALIVE_AGENT = new https.Agent({ keepAlive: true });
 
+function getCodexSkillsDir() {
+    const envCodexHome = typeof process.env.CODEX_HOME === 'string' ? process.env.CODEX_HOME.trim() : '';
+    if (envCodexHome) {
+        const target = path.join(envCodexHome, 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
+    if (xdgConfig) {
+        const target = path.join(xdgConfig, 'codex', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = path.join(os.homedir(), '.config', 'codex', 'skills');
+    return resolveExistingDir([homeConfigDir], CODEX_SKILLS_DIR);
+}
+
+function getClaudeSkillsDir() {
+    const envClaudeHome = typeof process.env.CLAUDE_HOME === 'string' && process.env.CLAUDE_HOME.trim()
+        ? process.env.CLAUDE_HOME.trim()
+        : (typeof process.env.CLAUDE_CONFIG_DIR === 'string' ? process.env.CLAUDE_CONFIG_DIR.trim() : '');
+    if (envClaudeHome) {
+        const target = path.join(envClaudeHome, 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
+    if (xdgConfig) {
+        const target = path.join(xdgConfig, 'claude', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = path.join(os.homedir(), '.config', 'claude', 'skills');
+    return resolveExistingDir([homeConfigDir], CLAUDE_SKILLS_DIR);
+}
+
 function resolveWebPort() {
     const raw = process.env.CODEXMATE_PORT;
     if (!raw) return DEFAULT_WEB_PORT;
@@ -202,13 +246,14 @@ stream_idle_timeout_ms = 300000
 
 let g_initNotice = '';
 let g_sessionListCache = new Map();
+let g_exactMessageCountCache = new Map();
 let g_modelsCache = new Map();
 let g_modelsInFlight = new Map();
 let g_builtinProxyRuntime = null;
 const DEFAULT_LOCAL_PROVIDER_NAME = 'local';
 
 function isBuiltinProxyProvider(providerName) {
-    return typeof providerName === 'string' && providerName.trim() === BUILTIN_PROXY_PROVIDER_NAME;
+    return typeof providerName === 'string' && providerName.trim().toLowerCase() === BUILTIN_PROXY_PROVIDER_NAME.toLowerCase();
 }
 
 function isReservedProviderNameForCreation(providerName) {
@@ -881,12 +926,18 @@ function normalizeAuthRegistry(raw) {
     };
 }
 
+function ensureAuthProfileStoragePrepared() {
+    ensureDir(AUTH_PROFILES_DIR);
+}
+
 function readAuthRegistry() {
+    ensureAuthProfileStoragePrepared();
     const parsed = readJsonFile(AUTH_REGISTRY_FILE, null);
     return normalizeAuthRegistry(parsed);
 }
 
 function writeAuthRegistry(registry) {
+    ensureAuthProfileStoragePrepared();
     writeJsonAtomic(AUTH_REGISTRY_FILE, normalizeAuthRegistry(registry));
 }
 
@@ -945,6 +996,7 @@ function listAuthProfilesInfo() {
 }
 
 function upsertAuthProfile(payload, options = {}) {
+    ensureAuthProfileStoragePrepared();
     const safePayload = parseAuthProfileJson(JSON.stringify(payload || {}));
     const sourceFile = typeof options.sourceFile === 'string' ? options.sourceFile : '';
     const preferredName = normalizeAuthProfileName(options.name || '');
@@ -1034,6 +1086,7 @@ function importAuthProfileFromUpload(payload = {}) {
 }
 
 function switchAuthProfile(name, options = {}) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         throw new Error('认证名称不能为空');
@@ -1079,6 +1132,7 @@ function switchAuthProfile(name, options = {}) {
 }
 
 function deleteAuthProfile(name) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         return { error: '认证名称不能为空' };
@@ -1127,6 +1181,7 @@ function deleteAuthProfile(name) {
 }
 
 function resolveAuthTokenFromCurrentProfile() {
+    ensureAuthProfileStoragePrepared();
     const registry = readAuthRegistry();
     if (!registry.current) return '';
     const profile = registry.items.find((item) => item.name === registry.current);
@@ -1382,8 +1437,40 @@ function normalizeCodexSkillName(name) {
     return { name: value };
 }
 
-function isSkillDirectoryEntry(entryName) {
-    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+function normalizeSkillTargetApp(app) {
+    const value = typeof app === 'string' ? app.trim().toLowerCase() : '';
+    return SKILL_TARGETS.some((item) => item.app === value) ? value : '';
+}
+
+function getSkillTargetByApp(app) {
+    const normalizedApp = normalizeSkillTargetApp(app);
+    if (!normalizedApp) return null;
+    return SKILL_TARGETS.find((item) => item.app === normalizedApp) || null;
+}
+
+function resolveSkillTarget(params = {}, defaultApp = 'codex') {
+    const hasExplicitTargetApp = !!(params && typeof params === 'object'
+        && Object.prototype.hasOwnProperty.call(params, 'targetApp'));
+    const hasExplicitTarget = !!(params && typeof params === 'object'
+        && Object.prototype.hasOwnProperty.call(params, 'target'));
+    const hasAnyExplicitTarget = hasExplicitTargetApp || hasExplicitTarget;
+    const rawTargetApp = hasExplicitTargetApp ? params.targetApp : '';
+    const rawTarget = hasExplicitTarget ? params.target : '';
+    const raw = rawTargetApp || rawTarget || '';
+    if (hasAnyExplicitTarget && raw === '') {
+        return null;
+    }
+    if (hasAnyExplicitTarget && !getSkillTargetByApp(raw)) {
+        return null;
+    }
+    return getSkillTargetByApp(raw)
+        || getSkillTargetByApp(defaultApp)
+        || SKILL_TARGETS[0]
+        || null;
+}
+
+function isSkillDirectoryEntryAtRoot(rootDir, entryName) {
+    const targetPath = path.join(rootDir, entryName);
     try {
         const stat = fs.statSync(targetPath);
         return stat.isDirectory();
@@ -1552,13 +1639,13 @@ function readCodexSkillMetadata(skillPath) {
     }
 }
 
-function getCodexSkillEntryInfoByName(entryName) {
-    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+function getSkillEntryInfoByName(rootDir, entryName) {
+    const targetPath = path.join(rootDir, entryName);
     const normalized = normalizeCodexSkillName(entryName);
     if (normalized.error) {
         return null;
     }
-    const relativePath = path.relative(CODEX_SKILLS_DIR, targetPath);
+    const relativePath = path.relative(rootDir, targetPath);
     if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
         return null;
     }
@@ -1569,7 +1656,7 @@ function getCodexSkillEntryInfoByName(entryName) {
         if (!lstat.isDirectory() && !isSymbolicLink) {
             return null;
         }
-        if (isSymbolicLink && !isSkillDirectoryEntry(entryName)) {
+        if (isSymbolicLink && !isSkillDirectoryEntryAtRoot(rootDir, entryName)) {
             return null;
         }
         const metadata = readCodexSkillMetadata(targetPath);
@@ -1587,26 +1674,34 @@ function getCodexSkillEntryInfoByName(entryName) {
     }
 }
 
-function listCodexSkills() {
-    if (!fs.existsSync(CODEX_SKILLS_DIR)) {
+function listSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    if (!fs.existsSync(target.dir)) {
         return {
-            root: CODEX_SKILLS_DIR,
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir,
             exists: false,
             items: []
         };
     }
     try {
-        const entries = fs.readdirSync(CODEX_SKILLS_DIR, { withFileTypes: true });
+        const entries = fs.readdirSync(target.dir, { withFileTypes: true });
         const items = entries
             .map((entry) => {
                 const name = entry && entry.name ? entry.name : '';
                 if (!name || name.startsWith('.')) return null;
-                return getCodexSkillEntryInfoByName(name);
+                return getSkillEntryInfoByName(target.dir, name);
             })
             .filter(Boolean)
             .sort((a, b) => a.displayName.localeCompare(b.displayName, 'zh-Hans-CN'));
         return {
-            root: CODEX_SKILLS_DIR,
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir,
             exists: true,
             items
         };
@@ -1615,6 +1710,10 @@ function listCodexSkills() {
     }
 }
 
+function listCodexSkills() {
+    return listSkills({ targetApp: 'codex' });
+}
+
 function listSkillEntriesByRoot(rootDir) {
     if (!rootDir || !fs.existsSync(rootDir)) {
         return [];
@@ -1660,8 +1759,13 @@ function listSkillEntriesByRoot(rootDir) {
     }
 }
 
-function scanUnmanagedCodexSkills() {
-    const existing = listCodexSkills();
+function scanUnmanagedSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
+    const existing = listSkills({ targetApp: target.app });
     if (existing.error) {
         return { error: existing.error };
     }
@@ -1670,9 +1774,14 @@ function scanUnmanagedCodexSkills() {
         .filter(Boolean));
 
     const items = [];
-    for (const source of SKILL_IMPORT_SOURCES) {
+    const sources = SKILL_IMPORT_SOURCES.filter((source) => source.app !== target.app);
+    for (const source of sources) {
         const sourceEntries = listSkillEntriesByRoot(source.dir);
         for (const entry of sourceEntries) {
+            const targetCandidate = path.join(targetRoot, entry.name);
+            if (fs.existsSync(targetCandidate)) {
+                continue;
+            }
             if (existingNames.has(entry.name)) {
                 continue;
             }
@@ -1698,9 +1807,11 @@ function scanUnmanagedCodexSkills() {
     });
 
     return {
-        root: CODEX_SKILLS_DIR,
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: target.dir,
         items,
-        sources: SKILL_IMPORT_SOURCES.map((source) => ({
+        sources: sources.map((source) => ({
             app: source.app,
             label: source.label,
             path: source.dir,
@@ -1709,14 +1820,21 @@ function scanUnmanagedCodexSkills() {
     };
 }
 
-function importCodexSkills(params = {}) {
+function scanUnmanagedCodexSkills() {
+    return scanUnmanagedSkills({ targetApp: 'codex' });
+}
+
+function importSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
     const rawItems = Array.isArray(params.items) ? params.items : [];
     if (!rawItems.length) {
         return { error: '请先选择要导入的 skill' };
     }
 
-    ensureDir(CODEX_SKILLS_DIR);
-
     const imported = [];
     const failed = [];
     const dedup = new Set();
@@ -1741,6 +1859,14 @@ function importCodexSkills(params = {}) {
             });
             continue;
         }
+        if (source.app === target.app) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                error: '来源与目标相同，无需导入'
+            });
+            continue;
+        }
         const dedupKey = `${source.app}:${normalizedName.name}`;
         if (dedup.has(dedupKey)) {
             continue;
@@ -1766,8 +1892,8 @@ function importCodexSkills(params = {}) {
             continue;
         }
 
-        const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-        const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
+        const targetPath = path.join(targetRoot, normalizedName.name);
+        const targetRelative = path.relative(targetRoot, targetPath);
         if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
             failed.push({
                 name: normalizedName.name,
@@ -1780,7 +1906,7 @@ function importCodexSkills(params = {}) {
             failed.push({
                 name: normalizedName.name,
                 sourceApp: source.app,
-                error: 'Codex 中已存在同名 skill'
+                error: `${target.label} 中已存在同名 skill`
             });
             continue;
         }
@@ -1806,6 +1932,15 @@ function importCodexSkills(params = {}) {
                 });
                 continue;
             }
+            if (isPathInside(targetRoot, sourceDirForCopy)) {
+                failed.push({
+                    name: normalizedName.name,
+                    sourceApp: source.app,
+                    error: '目标路径不能位于来源 skill 目录内'
+                });
+                continue;
+            }
+            ensureDir(targetRoot);
             const visitedRealPaths = new Set([sourceDirForCopy]);
             copyDirRecursive(sourceDirForCopy, targetPath, {
                 dereferenceSymlinks: true,
@@ -1817,6 +1952,8 @@ function importCodexSkills(params = {}) {
                 name: normalizedName.name,
                 sourceApp: source.app,
                 sourceLabel: source.label,
+                targetApp: target.app,
+                targetLabel: target.label,
                 path: targetPath
             });
         } catch (e) {
@@ -1837,10 +1974,16 @@ function importCodexSkills(params = {}) {
         success: failed.length === 0,
         imported,
         failed,
-        root: CODEX_SKILLS_DIR
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: targetRoot
     };
 }
 
+function importCodexSkills(params = {}) {
+    return importSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function collectSkillDirectoriesFromRoot(rootDir, limit = MAX_SKILLS_ZIP_ENTRY_COUNT) {
     const results = [];
     let truncated = false;
@@ -1894,15 +2037,22 @@ function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbac
     return normalizeCodexSkillName(candidate);
 }
 
-async function importCodexSkillsFromZipFile(zipPath, options = {}) {
+async function importSkillsFromZipFile(zipPath, options = {}) {
     const fallbackName = typeof options.fallbackName === 'string' ? options.fallbackName : '';
     const tempDir = typeof options.tempDir === 'string' ? options.tempDir : '';
     const imported = [];
     const failed = [];
     const dedupNames = new Set();
     const extractionRoot = path.join(tempDir || path.dirname(zipPath), 'extract');
+    let target = null;
+    let targetRoot = '';
 
     try {
+        target = resolveSkillTarget(options, 'codex');
+        if (!target) {
+            return { error: '目标宿主不支持' };
+        }
+        targetRoot = resolveCopyTargetRoot(target.dir);
         await inspectZipArchiveLimits(zipPath, {
             maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
             maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
@@ -1918,7 +2068,6 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             return { error: '压缩包中的技能目录数量超出导入上限' };
         }
 
-        ensureDir(CODEX_SKILLS_DIR);
         for (const skillDir of discoveredDirs) {
             const normalizedName = resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName);
             if (normalizedName.error) {
@@ -1934,8 +2083,8 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             }
             dedupNames.add(dedupKey);
 
-            const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-            const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
+            const targetPath = path.join(targetRoot, normalizedName.name);
+            const targetRelative = path.relative(targetRoot, targetPath);
             if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
                 failed.push({
                     name: normalizedName.name,
@@ -1946,7 +2095,7 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             if (fs.existsSync(targetPath)) {
                 failed.push({
                     name: normalizedName.name,
-                    error: 'Codex 中已存在同名 skill'
+                    error: `${target.label} 中已存在同名 skill`
                 });
                 continue;
             }
@@ -1962,6 +2111,14 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                     });
                     continue;
                 }
+                if (isPathInside(targetRoot, sourceRealPath)) {
+                    failed.push({
+                        name: normalizedName.name,
+                        error: '目标路径不能位于来源 skill 目录内'
+                    });
+                    continue;
+                }
+                ensureDir(targetRoot);
                 const visitedRealPaths = new Set([sourceRealPath]);
                 copyDirRecursive(sourceRealPath, targetPath, {
                     dereferenceSymlinks: true,
@@ -1971,6 +2128,8 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 copiedToTarget = true;
                 imported.push({
                     name: normalizedName.name,
+                    targetApp: target.app,
+                    targetLabel: target.label,
                     path: targetPath
                 });
             } catch (e) {
@@ -1991,7 +2150,9 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 error: failed[0].error || '导入失败',
                 imported,
                 failed,
-                root: CODEX_SKILLS_DIR
+                targetApp: target.app,
+                targetLabel: target.label,
+                root: targetRoot
             };
         }
 
@@ -1999,7 +2160,9 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
             success: failed.length === 0,
             imported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: targetRoot
         };
     } catch (e) {
         return {
@@ -2018,21 +2181,40 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
     }
 }
 
-async function importCodexSkillsFromZip(payload = {}) {
+async function importCodexSkillsFromZipFile(zipPath, options = {}) {
+    return importSkillsFromZipFile(zipPath, { ...(options || {}), targetApp: 'codex' });
+}
+
+async function importSkillsFromZip(payload = {}) {
     if (!payload || typeof payload.fileBase64 !== 'string' || !payload.fileBase64.trim()) {
         return { error: '缺少技能压缩包内容' };
     }
-    const upload = writeUploadZip(payload.fileBase64, 'codex-skills-import', payload.fileName || 'codex-skills.zip');
+    const fallbackTarget = resolveSkillTarget(payload, 'codex');
+    const fallbackTargetApp = fallbackTarget ? fallbackTarget.app : 'codex';
+    const fallbackName = payload.fileName || `${fallbackTargetApp}-skills.zip`;
+    const upload = writeUploadZip(payload.fileBase64, 'codex-skills-import', fallbackName);
     if (upload.error) {
         return { error: upload.error };
     }
-    return importCodexSkillsFromZipFile(upload.zipPath, {
-        tempDir: upload.tempDir,
-        fallbackName: payload.fileName || ''
-    });
+    const importOptions = { tempDir: upload.tempDir, fallbackName };
+    if (Object.prototype.hasOwnProperty.call(payload, 'targetApp')) {
+        importOptions.targetApp = payload.targetApp;
+    }
+    if (Object.prototype.hasOwnProperty.call(payload, 'target')) {
+        importOptions.target = payload.target;
+    }
+    return importSkillsFromZipFile(upload.zipPath, importOptions);
 }
 
-async function exportCodexSkills(params = {}) {
+async function importCodexSkillsFromZip(payload = {}) {
+    return importSkillsFromZip({ ...(payload || {}), targetApp: 'codex' });
+}
+
+async function exportSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
     const rawNames = Array.isArray(params.names) ? params.names : [];
     const uniqueNames = Array.from(new Set(rawNames
         .map((item) => (typeof item === 'string' ? item.trim() : ''))
@@ -2054,8 +2236,8 @@ async function exportCodexSkills(params = {}) {
                 failed.push({ name: rawName, error: normalizedName.error });
                 continue;
             }
-            const sourcePath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-            const sourceRelative = path.relative(CODEX_SKILLS_DIR, sourcePath);
+            const sourcePath = path.join(target.dir, normalizedName.name);
+            const sourceRelative = path.relative(target.dir, sourcePath);
             if (sourceRelative.startsWith('..') || path.isAbsolute(sourceRelative)) {
                 failed.push({ name: normalizedName.name, error: '来源路径非法' });
                 continue;
@@ -2101,12 +2283,14 @@ async function exportCodexSkills(params = {}) {
                 error: failed[0] && failed[0].error ? failed[0].error : '无可导出的 skill',
                 exported,
                 failed,
-                root: CODEX_SKILLS_DIR
+                targetApp: target.app,
+                targetLabel: target.label,
+                root: target.dir
             };
         }
 
         const randomToken = crypto.randomBytes(12).toString('hex');
-        const zipFileName = `codex-skills-${randomToken}.zip`;
+        const zipFileName = `${target.app}-skills-${randomToken}.zip`;
         const zipFilePath = path.join(os.tmpdir(), zipFileName);
         if (fs.existsSync(zipFilePath)) {
             try {
@@ -2125,14 +2309,18 @@ async function exportCodexSkills(params = {}) {
             downloadPath: artifact.downloadPath,
             exported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir
         };
     } catch (e) {
         return {
             error: `导出失败：${e && e.message ? e.message : '未知错误'}`,
             exported,
             failed,
-            root: CODEX_SKILLS_DIR
+            targetApp: target.app,
+            targetLabel: target.label,
+            root: target.dir
         };
     } finally {
         try {
@@ -2141,6 +2329,10 @@ async function exportCodexSkills(params = {}) {
     }
 }
 
+async function exportCodexSkills(params = {}) {
+    return exportSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function removeDirectoryRecursive(targetPath) {
     if (typeof fs.rmSync === 'function') {
         fs.rmSync(targetPath, { recursive: true, force: false });
@@ -2149,7 +2341,11 @@ function removeDirectoryRecursive(targetPath) {
     fs.rmdirSync(targetPath, { recursive: true });
 }
 
-function deleteCodexSkills(params = {}) {
+function deleteSkills(params = {}) {
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
     const rawList = Array.isArray(params.names) ? params.names : [];
     const uniqueNames = Array.from(new Set(rawList
         .map((item) => (typeof item === 'string' ? item.trim() : ''))
@@ -2167,8 +2363,8 @@ function deleteCodexSkills(params = {}) {
             continue;
         }
 
-        const skillPath = path.join(CODEX_SKILLS_DIR, normalized.name);
-        const relativePath = path.relative(CODEX_SKILLS_DIR, skillPath);
+        const skillPath = path.join(target.dir, normalized.name);
+        const relativePath = path.relative(target.dir, skillPath);
         if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
             failed.push({ name: normalized.name, error: '技能路径非法' });
             continue;
@@ -2198,10 +2394,16 @@ function deleteCodexSkills(params = {}) {
         success: failed.length === 0,
         deleted,
         failed,
-        root: CODEX_SKILLS_DIR
+        targetApp: target.app,
+        targetLabel: target.label,
+        root: target.dir
     };
 }
 
+function deleteCodexSkills(params = {}) {
+    return deleteSkills({ ...(params || {}), targetApp: 'codex' });
+}
+
 function readAgentsFile(params = {}) {
     const filePath = resolveAgentsFilePath(params);
     const dirCheck = validateAgentsBaseDir(filePath);
@@ -2218,6 +2420,15 @@ function readAgentsFile(params = {}) {
         };
     }
 
+    if (params.metaOnly) {
+        return {
+            exists: true,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n'
+        };
+    }
+
     try {
         const raw = fs.readFileSync(filePath, 'utf-8');
         return {
@@ -2251,6 +2462,48 @@ function applyAgentsFile(params = {}) {
     }
 }
 
+function normalizeDiffText(input) {
+    const safe = typeof input === 'string' ? input : '';
+    return normalizeLineEnding(stripUtf8Bom(safe), '\n');
+}
+
+function buildAgentsDiff(params = {}) {
+    const hasBaseContent = typeof params.baseContent === 'string';
+    const contextRaw = typeof params.context === 'string' ? params.context.trim() : '';
+    const context = contextRaw || 'codex';
+    const metaOnly = hasBaseContent;
+    let readResult;
+    if (context === 'openclaw') {
+        readResult = readOpenclawAgentsFile({ metaOnly });
+    } else if (context === 'openclaw-workspace') {
+        readResult = readOpenclawWorkspaceFile({ ...params, metaOnly });
+    } else if (context === 'codex') {
+        readResult = readAgentsFile({ ...params, metaOnly });
+    } else {
+        return { error: `Unsupported agents diff context: ${context}` };
+    }
+    if (readResult && readResult.error) {
+        return { error: readResult.error };
+    }
+
+    const beforeText = normalizeDiffText(
+        hasBaseContent ? params.baseContent : (readResult && readResult.content ? readResult.content : '')
+    );
+    const afterText = normalizeDiffText(params.content);
+    const diff = buildLineDiff(beforeText, afterText);
+    const hasChanges = diff.truncated ? beforeText !== afterText : (diff.stats.added > 0 || diff.stats.removed > 0);
+    return {
+        diff: {
+            ...diff,
+            hasChanges
+        },
+        path: readResult && readResult.path ? readResult.path : '',
+        exists: !!(readResult && readResult.exists),
+        context,
+        configError: readResult && readResult.configError ? readResult.configError : ''
+    };
+}
+
 function resolveOpenclawWorkspaceDir(config) {
     const workspace = config
         && config.agents
@@ -2348,7 +2601,7 @@ function getOpenclawWorkspaceInfo() {
     };
 }
 
-function readOpenclawAgentsFile() {
+function readOpenclawAgentsFile(params = {}) {
     const workspaceInfo = getOpenclawWorkspaceInfo();
     const baseDir = workspaceInfo.workspaceDir;
     const filePath = path.join(baseDir, AGENTS_FILE_NAME);
@@ -2365,7 +2618,7 @@ function readOpenclawAgentsFile() {
         };
     }
 
-    const readResult = readAgentsFile({ baseDir });
+    const readResult = readAgentsFile({ baseDir, metaOnly: !!params.metaOnly });
     return {
         ...readResult,
         workspaceDir: baseDir,
@@ -2420,6 +2673,17 @@ function readOpenclawWorkspaceFile(params = {}) {
         };
     }
 
+    if (params.metaOnly) {
+        return {
+            exists: true,
+            path: filePath,
+            content: '',
+            lineEnding: os.EOL === '\r\n' ? '\r\n' : '\n',
+            workspaceDir: baseDir,
+            configError: workspaceInfo.configError
+        };
+    }
+
     try {
         const raw = fs.readFileSync(filePath, 'utf-8');
         return {
@@ -2921,11 +3185,40 @@ function buildVirtualDefaultConfig() {
     return toml.parse(EMPTY_CONFIG_FALLBACK_TEMPLATE);
 }
 
+function sanitizeRemovedBuiltinProxyProvider(config) {
+    const safeConfig = isPlainObject(config) ? config : {};
+    const providers = isPlainObject(safeConfig.model_providers) ? safeConfig.model_providers : null;
+    const currentProvider = typeof safeConfig.model_provider === 'string' ? safeConfig.model_provider.trim() : '';
+    const hasRemovedBuiltin = !!(providers && providers[BUILTIN_PROXY_PROVIDER_NAME]);
+    const currentIsRemovedBuiltin = currentProvider === BUILTIN_PROXY_PROVIDER_NAME;
+
+    if (!hasRemovedBuiltin && !currentIsRemovedBuiltin) {
+        return safeConfig;
+    }
+
+    const nextProviders = providers ? { ...providers } : {};
+    delete nextProviders[BUILTIN_PROXY_PROVIDER_NAME];
+    const providerNames = Object.keys(nextProviders);
+    const fallbackProvider = providerNames[0] || '';
+    const currentModels = readCurrentModels();
+    const fallbackModel = fallbackProvider
+        ? (currentModels[fallbackProvider] || (typeof safeConfig.model === 'string' ? safeConfig.model : ''))
+        : '';
+
+    return {
+        ...safeConfig,
+        model_providers: nextProviders,
+        model_provider: currentIsRemovedBuiltin ? fallbackProvider : safeConfig.model_provider,
+        model: currentIsRemovedBuiltin ? fallbackModel : safeConfig.model
+    };
+}
+
 function readConfigOrVirtualDefault() {
     if (fs.existsSync(CONFIG_FILE)) {
         try {
+            removePersistedBuiltinProxyProviderFromConfig();
             return {
-                config: readConfig(),
+                config: sanitizeRemovedBuiltinProxyProvider(readConfig()),
                 isVirtual: false,
                 reason: '',
                 detail: '',
@@ -2942,7 +3235,9 @@ function readConfigOrVirtualDefault() {
                 ? e.configDetail.trim()
                 : (e && e.message ? e.message : publicReason);
             return {
-                config: errorType === 'missing' ? buildVirtualDefaultConfig() : {},
+                config: errorType === 'missing'
+                    ? sanitizeRemovedBuiltinProxyProvider(buildVirtualDefaultConfig())
+                    : {},
                 isVirtual: true,
                 reason: publicReason,
                 detail,
@@ -2952,7 +3247,7 @@ function readConfigOrVirtualDefault() {
     }
 
     return {
-        config: buildVirtualDefaultConfig(),
+        config: sanitizeRemovedBuiltinProxyProvider(buildVirtualDefaultConfig()),
         isVirtual: true,
         reason: '未检测到 config.toml',
         detail: `配置文件不存在: ${CONFIG_FILE}`,
@@ -3048,8 +3343,8 @@ function getConfigTemplate(params = {}) {
             }
         } catch (e) {}
     }
-    const selectedProvider = params.provider || '';
-    const selectedModel = params.model || '';
+    const selectedProvider = typeof params.provider === 'string' ? params.provider.trim() : '';
+    const selectedModel = typeof params.model === 'string' ? params.model.trim() : '';
     let template = normalizeTopLevelConfigWithTemplate(content, selectedProvider, selectedModel);
     if (typeof params.serviceTier === 'string') {
         template = applyServiceTierToTemplate(template, params.serviceTier);
@@ -3126,7 +3421,7 @@ function addProviderToConfig(params = {}) {
         return { error: 'local provider 为系统保留名称，不可新增' };
     }
     if (isBuiltinProxyProvider(name) && !allowManaged) {
-        return { error: '本地代理配置为系统内建项，不可手动添加' };
+        return { error: 'codexmate-proxy 为保留名称，不可手动添加' };
     }
 
     ensureConfigDir();
@@ -3204,7 +3499,7 @@ function updateProviderInConfig(params = {}) {
         if (isDefaultLocalProvider(name)) {
             return { error: 'local provider 为系统保留项，不可编辑' };
         }
-        return { error: '本地代理配置为系统内建项，不可编辑' };
+        return { error: 'codexmate-proxy 为保留名称，不可编辑' };
     }
 
     try {
@@ -3222,7 +3517,7 @@ function deleteProviderFromConfig(params = {}) {
         if (isDefaultLocalProvider(name)) {
             return { error: 'local provider 为系统保留项，不可删除' };
         }
-        return { error: '本地代理配置为系统内建项，不可删除' };
+        return { error: 'codexmate-proxy 为保留名称，不可删除' };
     }
     if (!fs.existsSync(CONFIG_FILE)) {
         return { error: 'config.toml 不存在' };
@@ -3252,7 +3547,7 @@ function performProviderDeletion(name, options = {}) {
     if (isNonDeletableProvider(name)) {
         const msg = isDefaultLocalProvider(name)
             ? 'local provider 为系统保留项，不可删除'
-            : '本地代理配置为系统内建项，不可删除';
+            : 'codexmate-proxy 为保留名称，不可删除';
         if (!silent) console.error('错误:', msg);
         return { error: msg };
     }
@@ -3555,6 +3850,27 @@ function isPathInside(targetPath, rootPath) {
     return resolvedTarget.startsWith(rootWithSlash);
 }
 
+function resolveCopyTargetRoot(targetDir) {
+    const suffixSegments = [];
+    let current = path.resolve(targetDir || '');
+    while (current && !fs.existsSync(current)) {
+        const parent = path.dirname(current);
+        if (!parent || parent === current) {
+            break;
+        }
+        suffixSegments.unshift(path.basename(current));
+        current = parent;
+    }
+    let resolvedRoot = normalizePathForCompare(current || targetDir);
+    if (!resolvedRoot) {
+        resolvedRoot = path.resolve(targetDir || '');
+    }
+    for (const segment of suffixSegments) {
+        resolvedRoot = path.join(resolvedRoot, segment);
+    }
+    return resolvedRoot;
+}
+
 function collectJsonlFiles(rootDir, maxFiles = 5000) {
     if (!fs.existsSync(rootDir)) {
         return [];
@@ -3656,6 +3972,102 @@ function parseJsonlHeadRecords(filePath, maxBytes = SESSION_SUMMARY_READ_BYTES)
     return parseJsonlContent(headText);
 }
 
+function buildClaudeStoredIndexMessageCount(messageCount) {
+    const safeCount = Number.isFinite(Number(messageCount))
+        ? Math.max(0, Math.floor(Number(messageCount)))
+        : 0;
+    return safeCount + 1;
+}
+
+function getFileStatSafe(filePath) {
+    try {
+        return fs.statSync(filePath);
+    } catch (e) {
+        return null;
+    }
+}
+
+function getFileMtimeMs(filePath, stat = null) {
+    const fileStat = stat || getFileStatSafe(filePath);
+    if (!fileStat || !Number.isFinite(Number(fileStat.mtimeMs))) {
+        return 0;
+    }
+    return Math.max(0, Math.floor(Number(fileStat.mtimeMs)));
+}
+
+function isSessionSummaryMessageCountExact(stat, maxBytes = SESSION_SUMMARY_READ_BYTES) {
+    if (!stat || !Number.isFinite(Number(stat.size))) {
+        return false;
+    }
+    return Number(stat.size) <= maxBytes;
+}
+
+function buildExactMessageCountCacheKey(filePath, source, stat = null) {
+    const validSource = source === 'claude' ? 'claude' : (source === 'codex' ? 'codex' : '');
+    if (!validSource || !filePath) {
+        return '';
+    }
+    const mtimeMs = getFileMtimeMs(filePath, stat);
+    if (!mtimeMs) {
+        return '';
+    }
+    return `${validSource}:${path.resolve(filePath)}:${mtimeMs}`;
+}
+
+function readExactMessageCountCache(filePath, source, stat = null) {
+    const cacheKey = buildExactMessageCountCacheKey(filePath, source, stat);
+    if (!cacheKey) {
+        return null;
+    }
+    if (!g_exactMessageCountCache.has(cacheKey)) {
+        return null;
+    }
+    const cached = g_exactMessageCountCache.get(cacheKey);
+    g_exactMessageCountCache.delete(cacheKey);
+    g_exactMessageCountCache.set(cacheKey, cached);
+    return Number.isFinite(Number(cached)) ? Math.max(0, Math.floor(Number(cached))) : null;
+}
+
+function writeExactMessageCountCache(filePath, source, messageCount, stat = null) {
+    const cacheKey = buildExactMessageCountCacheKey(filePath, source, stat);
+    const safeCount = Number.isFinite(Number(messageCount))
+        ? Math.max(0, Math.floor(Number(messageCount)))
+        : null;
+    if (!cacheKey || safeCount === null) {
+        return;
+    }
+    if (g_exactMessageCountCache.has(cacheKey)) {
+        g_exactMessageCountCache.delete(cacheKey);
+    }
+    g_exactMessageCountCache.set(cacheKey, safeCount);
+    if (g_exactMessageCountCache.size <= EXACT_MESSAGE_COUNT_CACHE_MAX_ENTRIES) {
+        return;
+    }
+    const firstKey = g_exactMessageCountCache.keys().next().value;
+    if (firstKey) {
+        g_exactMessageCountCache.delete(firstKey);
+    }
+}
+
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const list = Array.isArray(items) ? items : [];
+    if (list.length === 0) {
+        return [];
+    }
+    const safeConcurrency = Math.max(1, Math.min(Math.floor(Number(concurrency)) || 1, list.length));
+    const results = new Array(list.length);
+    let nextIndex = 0;
+    const workers = Array.from({ length: safeConcurrency }, async () => {
+        while (nextIndex < list.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await mapper(list[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return results.filter((item) => item !== undefined);
+}
+
 function isBootstrapLikeText(text) {
     if (!text || typeof text !== 'string') {
         return false;
@@ -3723,48 +4135,349 @@ function countConversationMessagesInRecords(records, source) {
     return removeLeadingSystemMessage(messages).length;
 }
 
-function sortSessionsByUpdatedAt(items) {
-    items.sort((a, b) => {
-        const aTime = Date.parse(a.updatedAt || '') || 0;
-        const bTime = Date.parse(b.updatedAt || '') || 0;
-        return bTime - aTime;
-    });
-    return items;
-}
-
-function mergeAndLimitSessions(items, limit) {
-    const deduped = [];
-    const seen = new Set();
-    for (const item of items) {
-        if (!item || !item.filePath) continue;
-        const key = `${item.source}:${item.filePath}`;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        deduped.push(item);
+async function countConversationMessagesInFile(filePath, source) {
+    const fileStat = getFileStatSafe(filePath);
+    const cached = readExactMessageCountCache(filePath, source, fileStat);
+    if (cached !== null) {
+        return cached;
     }
 
-    return sortSessionsByUpdatedAt(deduped).slice(0, limit);
-}
+    let stream;
+    let rl;
+    let messageCount = 0;
+    let leadingSystem = true;
 
-function normalizeSessionPathFilter(pathFilter) {
-    if (typeof pathFilter !== 'string') {
-        return '';
+    try {
+        stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+        rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+        for await (const line of rl) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            } catch (e) {
+                continue;
+            }
+
+            let role = '';
+            let text = '';
+            if (source === 'codex') {
+                if (record.type === 'response_item' && record.payload && record.payload.type === 'message') {
+                    role = normalizeRole(record.payload.role);
+                    text = extractMessageText(record.payload.content);
+                }
+            } else {
+                role = normalizeRole(record.type);
+                if (role === 'assistant' || role === 'user' || role === 'system') {
+                    const content = record.message ? record.message.content : '';
+                    text = extractMessageText(content);
+                } else {
+                    role = '';
+                }
+            }
+            if (!role) {
+                continue;
+            }
+
+            const hasText = text.length > 0;
+            if (leadingSystem && (role === 'system' || (hasText && isBootstrapLikeText(text)))) {
+                continue;
+            }
+
+            leadingSystem = false;
+            messageCount += 1;
+        }
+        const safeCount = Math.max(0, messageCount);
+        writeExactMessageCountCache(filePath, source, safeCount, fileStat);
+        return safeCount;
+    } catch (e) {
+        const safeCount = countConversationMessagesInRecords(readJsonlRecords(filePath), source);
+        writeExactMessageCountCache(filePath, source, safeCount, fileStat);
+        return safeCount;
+    } finally {
+        if (rl) {
+            try { rl.close(); } catch (e) {}
+        }
+        if (stream && !stream.destroyed && stream.destroy) {
+            try { stream.destroy(); } catch (e) {}
+        }
     }
-    const trimmed = pathFilter.trim();
-    return trimmed ? trimmed.toLowerCase() : '';
 }
 
-function matchesSessionPathFilter(session, normalizedFilter) {
-    if (!normalizedFilter) {
-        return true;
+function appendSessionDetailTailMessage(state, record, source, lineIndex = -1) {
+    if (!state || typeof state !== 'object') {
+        return;
     }
-    if (!session || typeof session !== 'object') {
-        return false;
+
+    const message = extractMessageFromRecord(record, source);
+    if (!message) {
+        return;
     }
 
-    const cwd = typeof session.cwd === 'string' ? session.cwd.toLowerCase() : '';
-    return cwd.includes(normalizedFilter);
-}
+    const role = normalizeRole(message.role);
+    const text = typeof message.text === 'string' ? message.text : '';
+    if (!role || !text) {
+        return;
+    }
+
+    if (state.leadingSystem && (role === 'system' || isBootstrapLikeText(text))) {
+        return;
+    }
+
+    state.leadingSystem = false;
+    state.totalMessages += 1;
+    if (!Number.isFinite(state.tailLimit) || state.tailLimit <= 0) {
+        return;
+    }
+
+    if (state.messages.length >= state.tailLimit) {
+        state.messages.shift();
+    }
+    state.messages.push({
+        role,
+        text,
+        timestamp: toIsoTime(record && record.timestamp, ''),
+        recordLineIndex: Number.isInteger(lineIndex) ? lineIndex : -1
+    });
+}
+
+function applySessionDetailRecordMetadata(record, source, state) {
+    if (!state || typeof state !== 'object' || !record) {
+        return;
+    }
+
+    if (record.timestamp) {
+        state.updatedAt = toIsoTime(record.timestamp, state.updatedAt);
+    }
+
+    if (source === 'codex') {
+        if (record.type === 'session_meta' && record.payload) {
+            state.sessionId = record.payload.id || state.sessionId;
+            state.cwd = record.payload.cwd || state.cwd;
+        }
+        return;
+    }
+
+    if (!state.sessionId && record.sessionId) {
+        state.sessionId = record.sessionId;
+    }
+    if (!state.cwd && record.cwd) {
+        state.cwd = record.cwd;
+    }
+}
+
+function extractSessionDetailPreviewFromRecords(records, source, messageLimit) {
+    const safeMessageLimit = Number.isFinite(Number(messageLimit))
+        ? Math.max(1, Math.floor(Number(messageLimit)))
+        : DEFAULT_SESSION_DETAIL_MESSAGES;
+    const state = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        tailLimit: safeMessageLimit,
+        totalMessages: 0,
+        leadingSystem: true
+    };
+
+    for (let lineIndex = 0; lineIndex < records.length; lineIndex++) {
+        const record = records[lineIndex];
+        applySessionDetailRecordMetadata(record, source, state);
+        appendSessionDetailTailMessage(state, record, source, lineIndex);
+    }
+
+    return state;
+}
+
+async function extractSessionDetailPreviewFromFile(filePath, source, messageLimit) {
+    const safeMessageLimit = Number.isFinite(Number(messageLimit))
+        ? Math.max(1, Math.floor(Number(messageLimit)))
+        : DEFAULT_SESSION_DETAIL_MESSAGES;
+    const state = {
+        sessionId: '',
+        cwd: '',
+        updatedAt: '',
+        messages: [],
+        tailLimit: safeMessageLimit,
+        totalMessages: 0,
+        leadingSystem: true
+    };
+
+    let stream;
+    let rl;
+    try {
+        stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+        rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+        let lineIndex = 0;
+        for await (const line of rl) {
+            const currentLineIndex = lineIndex;
+            lineIndex += 1;
+
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            } catch (e) {
+                continue;
+            }
+
+            applySessionDetailRecordMetadata(record, source, state);
+            appendSessionDetailTailMessage(state, record, source, currentLineIndex);
+        }
+        return state;
+    } catch (e) {
+        return extractSessionDetailPreviewFromRecords(readJsonlRecords(filePath), source, safeMessageLimit);
+    } finally {
+        if (rl) {
+            try { rl.close(); } catch (e) {}
+        }
+        if (stream && !stream.destroyed && stream.destroy) {
+            try { stream.destroy(); } catch (e) {}
+        }
+    }
+}
+
+async function resolveSessionTrashEntryExactMessageCount(entry) {
+    const normalizedEntry = normalizeSessionTrashEntry(entry);
+    if (!normalizedEntry) {
+        return null;
+    }
+    const trashFilePath = resolveSessionTrashFilePath(normalizedEntry);
+    if (!trashFilePath || !fs.existsSync(trashFilePath)) {
+        return normalizedEntry;
+    }
+    const trashFileStat = getFileStatSafe(trashFilePath);
+    const trashFileMtimeMs = getFileMtimeMs(trashFilePath, trashFileStat);
+    if (
+        Number.isFinite(Number(normalizedEntry.messageCount))
+        && normalizedEntry.messageCount >= 0
+        && trashFileMtimeMs > 0
+        && normalizedEntry.messageCountMtimeMs === trashFileMtimeMs
+    ) {
+        return normalizedEntry;
+    }
+
+    const exactMessageCount = await countConversationMessagesInFile(trashFilePath, normalizedEntry.source);
+    if (!Number.isFinite(Number(exactMessageCount))) {
+        return normalizedEntry;
+    }
+
+    const safeMessageCount = Math.max(0, Math.floor(Number(exactMessageCount)));
+    if (
+        normalizedEntry.messageCount === safeMessageCount
+        && normalizedEntry.messageCountMtimeMs === trashFileMtimeMs
+    ) {
+        return normalizedEntry;
+    }
+
+    return {
+        ...normalizedEntry,
+        messageCount: safeMessageCount,
+        messageCountMtimeMs: trashFileMtimeMs
+    };
+}
+
+async function hydrateSessionTrashEntries(entries, options = {}) {
+    const source = options.source === 'claude' ? 'claude' : (options.source === 'codex' ? 'codex' : 'all');
+    const hydratedEntries = await mapWithConcurrency(Array.isArray(entries) ? entries : [], 8, async (entry) => {
+        const normalizedEntry = normalizeSessionTrashEntry(entry);
+        if (!normalizedEntry) {
+            return undefined;
+        }
+        return await resolveSessionTrashEntryExactMessageCount(normalizedEntry);
+    });
+
+    if (source === 'codex' || source === 'claude') {
+        return hydratedEntries.filter((entry) => entry.source === source);
+    }
+    return hydratedEntries;
+}
+
+async function hydrateSessionItemsExactMessageCount(items) {
+    return await mapWithConcurrency(Array.isArray(items) ? items : [], 8, async (item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return undefined;
+        }
+        if (item.__messageCountExact === true) {
+            return item;
+        }
+        const source = item.source === 'claude' ? 'claude' : (item.source === 'codex' ? 'codex' : '');
+        const filePath = typeof item.filePath === 'string' ? item.filePath : '';
+        if (!source || !filePath || !fs.existsSync(filePath)) {
+            return item;
+        }
+
+        const exactMessageCount = await countConversationMessagesInFile(filePath, source);
+        if (!Number.isFinite(Number(exactMessageCount))) {
+            return item;
+        }
+
+        const safeMessageCount = Math.max(0, Math.floor(Number(exactMessageCount)));
+        if (Number(item.messageCount) === safeMessageCount) {
+            return {
+                ...item,
+                __messageCountExact: true
+            };
+        }
+
+        return {
+            ...item,
+            messageCount: safeMessageCount,
+            __messageCountExact: true
+        };
+    });
+}
+
+function sortSessionsByUpdatedAt(items) {
+    items.sort((a, b) => {
+        const aTime = Date.parse(a.updatedAt || '') || 0;
+        const bTime = Date.parse(b.updatedAt || '') || 0;
+        return bTime - aTime;
+    });
+    return items;
+}
+
+function mergeAndLimitSessions(items, limit) {
+    const deduped = [];
+    const seen = new Set();
+    for (const item of items) {
+        if (!item || !item.filePath) continue;
+        const key = `${item.source}:${item.filePath}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push(item);
+    }
+
+    return sortSessionsByUpdatedAt(deduped).slice(0, limit);
+}
+
+function normalizeSessionPathFilter(pathFilter) {
+    if (typeof pathFilter !== 'string') {
+        return '';
+    }
+    const trimmed = pathFilter.trim();
+    return trimmed ? trimmed.toLowerCase() : '';
+}
+
+function matchesSessionPathFilter(session, normalizedFilter) {
+    if (!normalizedFilter) {
+        return true;
+    }
+    if (!session || typeof session !== 'object') {
+        return false;
+    }
+
+    const cwd = typeof session.cwd === 'string' ? session.cwd.toLowerCase() : '';
+    return cwd.includes(normalizedFilter);
+}
 
 function normalizeQueryTokens(query) {
     if (typeof query !== 'string') {
@@ -4240,6 +4953,7 @@ function parseCodexSessionSummary(filePath) {
         createdAt,
         updatedAt,
         messageCount,
+        __messageCountExact: isSessionSummaryMessageCountExact(stat),
         filePath,
         keywords: [],
         capabilities: {}
@@ -4329,6 +5043,7 @@ function parseClaudeSessionSummary(filePath) {
         createdAt,
         updatedAt,
         messageCount,
+        __messageCountExact: isSessionSummaryMessageCountExact(stat),
         filePath,
         keywords: [],
         capabilities: { code: true }
@@ -4425,7 +5140,8 @@ function listClaudeSessions(limit, options = {}) {
             }
             filePath = filePath ? path.resolve(filePath) : '';
 
-            if (!fs.existsSync(filePath)) {
+            const fileStat = getFileStatSafe(filePath);
+            if (!fileStat) {
                 continue;
             }
 
@@ -4434,7 +5150,7 @@ function listClaudeSessions(limit, options = {}) {
             let title = truncateText(entry.summary || entry.firstPrompt || sessionId, 120);
             let messageCount = Number.isFinite(entry.messageCount) ? Math.max(0, entry.messageCount - 1) : 0;
 
-            const quickRecords = parseJsonlHeadRecords(filePath, SESSION_TITLE_READ_BYTES);
+            const quickRecords = parseJsonlHeadRecords(filePath, SESSION_SUMMARY_READ_BYTES);
             if (quickRecords.length > 0) {
                 const filteredCount = countConversationMessagesInRecords(quickRecords, 'claude');
                 if (filteredCount > 0 || messageCount === 0) {
@@ -4472,6 +5188,7 @@ function listClaudeSessions(limit, options = {}) {
                 createdAt,
                 updatedAt,
                 messageCount,
+                __messageCountExact: quickRecords.length > 0 && isSessionSummaryMessageCountExact(fileStat),
                 filePath,
                 keywords,
                 capabilities
@@ -4566,6 +5283,42 @@ function listAllSessions(params = {}) {
     return result;
 }
 
+async function listAllSessionsData(params = {}) {
+    const source = params.source === 'codex' || params.source === 'claude'
+        ? params.source
+        : 'all';
+    const rawLimit = Number(params.limit);
+    const limit = Number.isFinite(rawLimit)
+        ? Math.max(1, Math.min(rawLimit, MAX_SESSION_LIST_SIZE))
+        : 120;
+    const forceRefresh = !!params.forceRefresh;
+    const normalizedPathFilter = normalizeSessionPathFilter(params.pathFilter);
+    const queryTokens = expandSessionQueryTokens(normalizeQueryTokens(params.query));
+    const hasQuery = queryTokens.length > 0;
+    const cacheKey = hasQuery ? '' : `exact:${source}:${limit}:${normalizedPathFilter}`;
+    if (!hasQuery) {
+        const cached = getSessionListCache(cacheKey, forceRefresh);
+        if (cached) {
+            return cached;
+        }
+    }
+
+    const sessions = listAllSessions(params);
+    const hydratedSessions = await hydrateSessionItemsExactMessageCount(sessions);
+    const result = hydratedSessions.map((item) => {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return item;
+        }
+        const normalized = { ...item };
+        delete normalized.__messageCountExact;
+        return normalized;
+    });
+    if (!hasQuery) {
+        setSessionListCache(cacheKey, result);
+    }
+    return result;
+}
+
 function listSessionPaths(params = {}) {
     const source = typeof params.source === 'string' ? params.source.trim().toLowerCase() : '';
     if (source && source !== 'codex' && source !== 'claude' && source !== 'all') {
@@ -4647,6 +5400,19 @@ function resolveSessionFilePath(source, filePath, sessionId) {
     return '';
 }
 
+function getSessionFileArg(params = {}) {
+    if (!params || typeof params !== 'object') {
+        return '';
+    }
+    if (typeof params.filePath === 'string' && params.filePath.trim()) {
+        return params.filePath.trim();
+    }
+    if (typeof params.file === 'string' && params.file.trim()) {
+        return params.file.trim();
+    }
+    return '';
+}
+
 function findClaudeSessionIndexPath(sessionFilePath) {
     const root = getClaudeProjectsDir();
     if (!root || !sessionFilePath) {
@@ -4786,6 +5552,124 @@ function buildProxyListenUrl(settings) {
     return `http://${host}:${settings.port}`;
 }
 
+function buildBuiltinProxyProviderBaseUrl(settings) {
+    return `${buildProxyListenUrl(settings).replace(/\/+$/, '')}/v1`;
+}
+
+function buildBuiltinProxyProviderConfig(settings) {
+    return {
+        name: BUILTIN_PROXY_PROVIDER_NAME,
+        base_url: buildBuiltinProxyProviderBaseUrl(settings),
+        wire_api: 'responses',
+        requires_openai_auth: false,
+        preferred_auth_method: '',
+        request_max_retries: 4,
+        stream_max_retries: 10,
+        stream_idle_timeout_ms: 300000
+    };
+}
+
+function injectBuiltinProxyProvider(config) {
+    return isPlainObject(config) ? config : {};
+}
+
+function removePersistedBuiltinProxyProviderFromConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return { success: true, removed: false };
+    }
+
+    let config;
+    try {
+        config = readConfig();
+    } catch (e) {
+        return { error: e.message || '读取 config.toml 失败' };
+    }
+
+    if (!config.model_providers || !config.model_providers[BUILTIN_PROXY_PROVIDER_NAME]) {
+        return { success: true, removed: false };
+    }
+
+    const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
+    const hasBom = content.charCodeAt(0) === 0xFEFF;
+    const providerConfig = config.model_providers[BUILTIN_PROXY_PROVIDER_NAME];
+    const providerSegments = providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)
+        ? providerConfig.__codexmate_legacy_segments
+        : null;
+    const providerSegmentVariants = (() => {
+        const variants = [];
+        const seen = new Set();
+        const pushVariant = (segments) => {
+            const normalized = normalizeLegacySegments(segments);
+            const key = buildLegacySegmentsKey(normalized);
+            if (!key || seen.has(key)) return;
+            seen.add(key);
+            variants.push(normalized);
+        };
+        if (providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)) {
+            pushVariant(providerConfig.__codexmate_legacy_segments);
+        }
+        if (providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segment_variants)) {
+            for (const segments of providerConfig.__codexmate_legacy_segment_variants) {
+                pushVariant(segments);
+            }
+        }
+        if (providerSegments) {
+            pushVariant(providerSegments);
+        }
+        if (variants.length === 0) {
+            pushVariant(String(BUILTIN_PROXY_PROVIDER_NAME || '').split('.').filter((item) => item));
+        }
+        return variants;
+    })();
+
+    let updatedContent = null;
+    const combinedRanges = [];
+    for (const segments of providerSegmentVariants) {
+        combinedRanges.push(...findProviderSectionRanges(content, BUILTIN_PROXY_PROVIDER_NAME, segments));
+        combinedRanges.push(...findProviderDescendantSectionRanges(content, segments));
+    }
+    if (combinedRanges.length === 0) {
+        combinedRanges.push(...findProviderSectionRanges(content, BUILTIN_PROXY_PROVIDER_NAME, providerSegments));
+    }
+
+    if (combinedRanges.length > 0) {
+        const sorted = combinedRanges.sort((a, b) => b.start - a.start || b.end - a.end);
+        const seen = new Set();
+        let removedContent = content;
+        for (const range of sorted) {
+            const rangeKey = `${range.start}:${range.end}`;
+            if (seen.has(rangeKey)) continue;
+            seen.add(rangeKey);
+            removedContent = removedContent.slice(0, range.start) + removedContent.slice(range.end);
+        }
+        updatedContent = removedContent.replace(/\n{3,}/g, lineEnding + lineEnding);
+    }
+
+    if (!updatedContent) {
+        const rebuilt = JSON.parse(JSON.stringify(config));
+        delete rebuilt.model_providers[BUILTIN_PROXY_PROVIDER_NAME];
+        const hasMarker = content.includes(CODEXMATE_MANAGED_MARKER);
+        let rebuiltToml = toml.stringify(rebuilt).trimEnd();
+        rebuiltToml = rebuiltToml.replace(/\n/g, lineEnding);
+        if (hasMarker && !rebuiltToml.includes(CODEXMATE_MANAGED_MARKER)) {
+            rebuiltToml = `${CODEXMATE_MANAGED_MARKER}${lineEnding}${rebuiltToml}`;
+        }
+        updatedContent = rebuiltToml + lineEnding;
+        if (hasBom && updatedContent.charCodeAt(0) !== 0xFEFF) {
+            updatedContent = '\uFEFF' + updatedContent;
+        }
+    }
+
+    try {
+        writeConfig(updatedContent.trimEnd() + lineEnding);
+    } catch (e) {
+        return { error: e.message || '写入 config.toml 失败' };
+    }
+
+    return { success: true, removed: true };
+}
+
 function hasCodexConfigReadyForProxy() {
     const result = readConfigOrVirtualDefault();
     if (!result || result.isVirtual) {
@@ -5061,168 +5945,703 @@ function getBuiltinProxyStatus() {
     };
 }
 
-function applyBuiltinProxyProvider(params = {}) {
-    const settings = readBuiltinProxySettings();
-    const hostForUrl = formatHostForUrl(settings.host);
-    const baseUrl = `http://${hostForUrl}:${settings.port}`;
-
-    const { config } = readConfigOrVirtualDefault();
-    const providers = config && isPlainObject(config.model_providers) ? config.model_providers : {};
-    const exists = !!providers[BUILTIN_PROXY_PROVIDER_NAME];
-    const saveResult = exists
-        ? updateProviderInConfig({
-            name: BUILTIN_PROXY_PROVIDER_NAME,
-            url: baseUrl,
-            key: '',
-            allowManaged: true
-        })
-        : addProviderToConfig({
-            name: BUILTIN_PROXY_PROVIDER_NAME,
-            url: baseUrl,
-            key: '',
-            allowManaged: true
-        });
-
-    if (saveResult && saveResult.error) {
-        return saveResult;
+function applyBuiltinProxyProvider(params = {}) {
+    return { error: '该功能已移除' };
+}
+
+async function ensureBuiltinProxyForCodexDefault(params = {}) {
+    return { error: '该功能已移除' };
+}
+
+function removeClaudeSessionIndexEntry(indexPath, sessionFilePath, sessionId) {
+    if (!indexPath || !fs.existsSync(indexPath)) {
+        return { removed: false, entry: null };
+    }
+    const index = readJsonFile(indexPath, null);
+    if (!index || !Array.isArray(index.entries)) {
+        return { removed: false, entry: null };
+    }
+    const ignoreCase = process.platform === 'win32';
+    const resolvedFile = sessionFilePath
+        ? normalizePathForCompare(sessionFilePath, { ignoreCase })
+        : '';
+    let removedEntry = null;
+    const filtered = index.entries.filter((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            return false;
+        }
+        if (entry.fullPath) {
+            const expanded = expandHomePath(entry.fullPath);
+            const entryPath = expanded
+                ? normalizePathForCompare(expanded, { ignoreCase })
+                : '';
+            if (entryPath && resolvedFile && entryPath === resolvedFile) {
+                if (!removedEntry) {
+                    removedEntry = entry;
+                }
+                return false;
+            }
+        }
+        const entrySessionId = typeof entry.sessionId === 'string' ? entry.sessionId : '';
+        if (!resolvedFile && sessionId && entrySessionId === sessionId) {
+            if (!removedEntry) {
+                removedEntry = entry;
+            }
+            return false;
+        }
+        return true;
+    });
+    if (filtered.length === index.entries.length) {
+        return { removed: false, entry: null };
+    }
+    index.entries = filtered;
+    writeJsonAtomic(indexPath, index);
+    return {
+        removed: true,
+        entry: removedEntry && typeof removedEntry === 'object'
+            ? JSON.parse(JSON.stringify(removedEntry))
+            : null
+    };
+}
+
+function moveFileSync(sourcePath, targetPath) {
+    ensureDir(path.dirname(targetPath));
+    try {
+        fs.renameSync(sourcePath, targetPath);
+        return;
+    } catch (error) {
+        if (!error || error.code !== 'EXDEV') {
+            throw error;
+        }
+    }
+
+    fs.copyFileSync(sourcePath, targetPath);
+    try {
+        fs.unlinkSync(sourcePath);
+    } catch (error) {
+        try {
+            fs.unlinkSync(targetPath);
+        } catch (_) {}
+        throw error;
+    }
+}
+
+function buildSessionSummaryFallback(source, filePath, sessionId = '') {
+    const resolvedSessionId = sessionId || path.basename(filePath, '.jsonl');
+    const sourceLabel = source === 'claude' ? 'Claude Code' : 'Codex';
+    return {
+        source,
+        sourceLabel,
+        provider: source === 'claude' ? 'claude' : 'codex',
+        sessionId: resolvedSessionId,
+        title: resolvedSessionId,
+        cwd: '',
+        createdAt: '',
+        updatedAt: '',
+        messageCount: 0,
+        filePath,
+        keywords: [],
+        capabilities: source === 'claude' ? { code: true } : {}
+    };
+}
+
+function generateSessionTrashId() {
+    if (crypto.randomUUID) {
+        return `trash-${crypto.randomUUID()}`;
+    }
+    return `trash-${Date.now().toString(36)}-${crypto.randomBytes(8).toString('hex')}`;
+}
+
+function allocateSessionTrashTarget() {
+    ensureDir(SESSION_TRASH_FILES_DIR);
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+        const trashId = generateSessionTrashId();
+        const trashFileName = `${trashId}.jsonl`;
+        const trashFilePath = path.join(SESSION_TRASH_FILES_DIR, trashFileName);
+        if (!fs.existsSync(trashFilePath)) {
+            return { trashId, trashFileName, trashFilePath };
+        }
+    }
+    const fallbackId = `trash-${Date.now().toString(36)}-${crypto.randomBytes(8).toString('hex')}`;
+    return {
+        trashId: fallbackId,
+        trashFileName: `${fallbackId}.jsonl`,
+        trashFilePath: path.join(SESSION_TRASH_FILES_DIR, `${fallbackId}.jsonl`)
+    };
+}
+
+function normalizeSessionTrashEntry(entry) {
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+        return null;
+    }
+    const source = entry.source === 'claude' ? 'claude' : (entry.source === 'codex' ? 'codex' : '');
+    const trashId = typeof entry.trashId === 'string' ? entry.trashId.trim() : '';
+    if (!source || !trashId || trashId.includes('/') || trashId.includes('\\') || trashId.includes('\0')) {
+        return null;
+    }
+    const sessionId = typeof entry.sessionId === 'string' ? entry.sessionId.trim() : '';
+    const trashFileNameRaw = typeof entry.trashFileName === 'string' ? entry.trashFileName.trim() : '';
+    const trashFileName = path.basename(trashFileNameRaw || `${trashId}.jsonl`);
+    if (!trashFileName || trashFileName === '.' || trashFileName === '..' || trashFileName.includes('\0')) {
+        return null;
+    }
+    return {
+        trashId,
+        trashFileName,
+        source,
+        sourceLabel: source === 'claude' ? 'Claude Code' : 'Codex',
+        sessionId: sessionId || trashId,
+        title: typeof entry.title === 'string' && entry.title.trim() ? entry.title.trim() : (sessionId || trashId),
+        cwd: typeof entry.cwd === 'string' ? entry.cwd : '',
+        createdAt: typeof entry.createdAt === 'string' ? entry.createdAt : '',
+        updatedAt: typeof entry.updatedAt === 'string' ? entry.updatedAt : '',
+        deletedAt: typeof entry.deletedAt === 'string' ? entry.deletedAt : '',
+        messageCount: Number.isFinite(Number(entry.messageCount))
+            ? Math.max(0, Math.floor(Number(entry.messageCount)))
+            : 0,
+        messageCountMtimeMs: Number.isFinite(Number(entry.messageCountMtimeMs))
+            ? Math.max(0, Math.floor(Number(entry.messageCountMtimeMs)))
+            : 0,
+        originalFilePath: typeof entry.originalFilePath === 'string' ? entry.originalFilePath : '',
+        provider: typeof entry.provider === 'string' && entry.provider.trim()
+            ? entry.provider.trim()
+            : (source === 'claude' ? 'claude' : 'codex'),
+        keywords: normalizeKeywords(entry.keywords),
+        capabilities: normalizeCapabilities(entry.capabilities),
+        claudeIndexPath: typeof entry.claudeIndexPath === 'string' ? entry.claudeIndexPath : '',
+        claudeIndexEntry: entry.claudeIndexEntry && typeof entry.claudeIndexEntry === 'object' && !Array.isArray(entry.claudeIndexEntry)
+            ? entry.claudeIndexEntry
+            : null
+    };
+}
+
+function resolveSessionTrashFilePath(entry) {
+    const normalized = normalizeSessionTrashEntry(entry);
+    if (!normalized) {
+        return '';
+    }
+    const filePath = path.join(SESSION_TRASH_FILES_DIR, normalized.trashFileName);
+    return isPathInside(filePath, SESSION_TRASH_FILES_DIR) ? filePath : '';
+}
+
+function writeSessionTrashEntries(entries) {
+    writeJsonAtomic(SESSION_TRASH_INDEX_FILE, {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        entries
+    });
+}
+
+function readSessionTrashEntries(options = {}) {
+    const cleanup = options.cleanup !== false;
+    const parsed = readJsonFile(SESSION_TRASH_INDEX_FILE, null);
+    if (!parsed || !Array.isArray(parsed.entries)) {
+        return [];
+    }
+
+    const normalizedEntries = [];
+    let dirty = false;
+    for (const rawEntry of parsed.entries) {
+        const entry = normalizeSessionTrashEntry(rawEntry);
+        if (!entry) {
+            dirty = true;
+            continue;
+        }
+        const trashFilePath = resolveSessionTrashFilePath(entry);
+        if (!trashFilePath || !fs.existsSync(trashFilePath)) {
+            dirty = true;
+            continue;
+        }
+        normalizedEntries.push(entry);
+    }
+
+    if (dirty && cleanup) {
+        writeSessionTrashEntries(normalizedEntries);
+    }
+
+    return normalizedEntries;
+}
+
+function buildSessionTrashEntry(summary, options = {}) {
+    const source = options.source === 'claude' ? 'claude' : 'codex';
+    const sessionId = options.sessionId || summary.sessionId || path.basename(options.originalFilePath || summary.filePath || '', '.jsonl');
+    const claudeIndexEntry = options.claudeIndexEntry && typeof options.claudeIndexEntry === 'object' && !Array.isArray(options.claudeIndexEntry)
+        ? options.claudeIndexEntry
+        : null;
+    const deletedAt = typeof options.deletedAt === 'string' && options.deletedAt
+        ? options.deletedAt
+        : new Date().toISOString();
+    const sourceLabel = source === 'claude' ? 'Claude Code' : 'Codex';
+    const fallbackTitle = truncateText(
+        (claudeIndexEntry && (claudeIndexEntry.summary || claudeIndexEntry.firstPrompt)) || sessionId,
+        120
+    );
+    const rawFallbackMessageCount = claudeIndexEntry && claudeIndexEntry.messageCount;
+    const fallbackMessageCount = Number.isFinite(Number(rawFallbackMessageCount))
+        ? Math.max(0, Number(rawFallbackMessageCount))
+        : 0;
+    const resolvedMessageCount = Number.isFinite(Number(summary && summary.messageCount))
+        ? Math.max(0, Math.floor(Number(summary.messageCount)))
+        : fallbackMessageCount;
+    const messageCountMtimeMs = getFileMtimeMs(options.trashFilePath);
+    const normalizedClaudeKeywords = claudeIndexEntry && Array.isArray(claudeIndexEntry.keywords)
+        ? normalizeKeywords(claudeIndexEntry.keywords)
+        : [];
+    const normalizedClaudeCapabilities = claudeIndexEntry
+        ? normalizeCapabilities(claudeIndexEntry.capabilities)
+        : {};
+    const normalizedSummaryKeywords = normalizeKeywords(summary.keywords);
+    const normalizedSummaryCapabilities = normalizeCapabilities(summary.capabilities);
+    return {
+        trashId: options.trashId,
+        trashFileName: options.trashFileName,
+        source,
+        sourceLabel,
+        sessionId,
+        title: summary.title || fallbackTitle || sessionId,
+        cwd: summary.cwd || (claudeIndexEntry && typeof claudeIndexEntry.projectPath === 'string' ? claudeIndexEntry.projectPath : ''),
+        createdAt: summary.createdAt || toIsoTime(claudeIndexEntry && claudeIndexEntry.created, ''),
+        updatedAt: summary.updatedAt || toIsoTime(claudeIndexEntry && (claudeIndexEntry.modified || claudeIndexEntry.fileMtime), ''),
+        deletedAt,
+        messageCount: resolvedMessageCount,
+        messageCountMtimeMs,
+        originalFilePath: options.originalFilePath || summary.filePath || '',
+        provider: (claudeIndexEntry && typeof claudeIndexEntry.provider === 'string' && claudeIndexEntry.provider.trim())
+            ? claudeIndexEntry.provider.trim()
+            : (summary.provider || (source === 'claude' ? 'claude' : 'codex')),
+        keywords: normalizedClaudeKeywords.length > 0 ? normalizedClaudeKeywords : normalizedSummaryKeywords,
+        capabilities: Object.keys(normalizedClaudeCapabilities).length > 0
+            ? normalizedClaudeCapabilities
+            : normalizedSummaryCapabilities,
+        claudeIndexPath: typeof options.claudeIndexPath === 'string' ? options.claudeIndexPath : '',
+        claudeIndexEntry
+    };
+}
+
+function resolveSessionRestoreTarget(entry) {
+    const normalized = normalizeSessionTrashEntry(entry);
+    if (!normalized) {
+        return '';
+    }
+    const root = normalized.source === 'claude' ? getClaudeProjectsDir() : getCodexSessionsDir();
+    const originalFilePath = typeof normalized.originalFilePath === 'string' ? normalized.originalFilePath.trim() : '';
+    if (!root || !originalFilePath) {
+        return '';
+    }
+    const expanded = expandHomePath(originalFilePath);
+    const resolved = expanded ? path.resolve(expanded) : '';
+    if (!resolved || !isPathInside(resolved, root)) {
+        return '';
+    }
+    return resolved;
+}
+
+function resolveClaudeSessionRestoreIndexPath(entry, targetFilePath) {
+    const fallbackIndexPath = findClaudeSessionIndexPath(targetFilePath) || path.join(path.dirname(targetFilePath), 'sessions-index.json');
+    const fallbackResolved = fallbackIndexPath ? path.resolve(fallbackIndexPath) : '';
+    const candidateRaw = entry && typeof entry.claudeIndexPath === 'string' ? entry.claudeIndexPath.trim() : '';
+    if (!candidateRaw) {
+        return fallbackResolved;
+    }
+    const claudeProjectsDir = getClaudeProjectsDir();
+    if (!claudeProjectsDir) {
+        return fallbackResolved;
+    }
+    const candidateIndexPath = path.resolve(candidateRaw);
+    if (path.basename(candidateIndexPath).toLowerCase() !== 'sessions-index.json') {
+        return fallbackResolved;
+    }
+    if (!isPathInside(candidateIndexPath, claudeProjectsDir)) {
+        return fallbackResolved;
+    }
+    if (!isPathInside(targetFilePath, path.dirname(candidateIndexPath))) {
+        return fallbackResolved;
+    }
+    return candidateIndexPath;
+}
+
+function buildClaudeSessionIndexEntry(entry, sessionFilePath) {
+    const normalized = normalizeSessionTrashEntry(entry);
+    const stored = normalized && normalized.claudeIndexEntry && typeof normalized.claudeIndexEntry === 'object'
+        ? JSON.parse(JSON.stringify(normalized.claudeIndexEntry))
+        : {};
+    const storedCapabilities = stored && stored.capabilities && typeof stored.capabilities === 'object' && !Array.isArray(stored.capabilities)
+        ? stored.capabilities
+        : null;
+    const storedKeywords = Array.isArray(stored && stored.keywords)
+        ? stored.keywords
+        : null;
+    const normalizedMessageCount = Number(normalized && normalized.messageCount);
+    const storedMessageCount = Number(stored && stored.messageCount);
+    let modifiedAt = '';
+    try {
+        modifiedAt = fs.statSync(sessionFilePath).mtime.toISOString();
+    } catch (e) {
+        modifiedAt = normalized && normalized.updatedAt ? normalized.updatedAt : new Date().toISOString();
+    }
+    const projectDir = path.dirname(sessionFilePath);
+    return {
+        ...stored,
+        sessionId: normalized.sessionId,
+        fullPath: sessionFilePath,
+        projectPath: (stored && typeof stored.projectPath === 'string' && stored.projectPath.trim())
+            ? stored.projectPath.trim()
+            : projectDir,
+        created: (stored && typeof stored.created === 'string' && stored.created.trim())
+            ? stored.created.trim()
+            : (normalized.createdAt || modifiedAt),
+        modified: modifiedAt,
+        summary: (stored && typeof stored.summary === 'string' && stored.summary.trim())
+            ? stored.summary.trim()
+            : (normalized.title || normalized.sessionId),
+        provider: (stored && typeof stored.provider === 'string' && stored.provider.trim())
+            ? stored.provider.trim()
+            : (normalized.provider || 'claude'),
+        capabilities: normalizeCapabilities(
+            storedCapabilities && Object.keys(storedCapabilities).length > 0
+                ? storedCapabilities
+                : normalized.capabilities
+        ),
+        keywords: normalizeKeywords(
+            storedKeywords && storedKeywords.length > 0
+                ? storedKeywords
+                : normalized.keywords
+        ),
+        messageCount: Number.isFinite(normalizedMessageCount)
+            ? buildClaudeStoredIndexMessageCount(normalizedMessageCount)
+            : (
+                Number.isFinite(storedMessageCount)
+                    ? Math.max(0, Math.floor(storedMessageCount))
+                    : buildClaudeStoredIndexMessageCount(normalized && normalized.messageCount)
+            )
+    };
+}
+
+function upsertClaudeSessionIndexEntry(indexPath, sessionFilePath, entry) {
+    if (!indexPath) {
+        return;
+    }
+    const parsed = readJsonFile(indexPath, null);
+    const index = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    const entries = Array.isArray(index.entries) ? index.entries : [];
+    const ignoreCase = process.platform === 'win32';
+    const resolvedFile = normalizePathForCompare(sessionFilePath, { ignoreCase });
+    const normalizedEntry = normalizeSessionTrashEntry(entry);
+    const filtered = entries.filter((item) => {
+        if (!item || typeof item !== 'object') {
+            return false;
+        }
+        if (typeof item.fullPath === 'string' && item.fullPath) {
+            const expanded = expandHomePath(item.fullPath);
+            const itemPath = expanded
+                ? normalizePathForCompare(expanded, { ignoreCase })
+                : '';
+            if (itemPath && itemPath === resolvedFile) {
+                return false;
+            }
+        }
+        const itemSessionId = typeof item.sessionId === 'string' ? item.sessionId : '';
+        if (!resolvedFile && normalizedEntry.sessionId && itemSessionId === normalizedEntry.sessionId) {
+            return false;
+        }
+        return true;
+    });
+    filtered.unshift(buildClaudeSessionIndexEntry(normalizedEntry, sessionFilePath));
+    index.entries = filtered;
+    if (!index.originalPath) {
+        index.originalPath = path.dirname(indexPath);
+    }
+    writeJsonAtomic(indexPath, index);
+}
+
+async function listSessionTrashItems(params = {}) {
+    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : 'all');
+    const countOnly = params.countOnly === true;
+    const rawLimit = Number(params.limit);
+    const limit = Number.isFinite(rawLimit)
+        ? Math.max(1, Math.min(rawLimit, MAX_SESSION_TRASH_LIST_SIZE))
+        : 200;
+    const allEntries = readSessionTrashEntries();
+    let items = source === 'codex' || source === 'claude'
+        ? allEntries.filter((entry) => entry.source === source)
+        : allEntries.slice();
+    items.sort((a, b) => {
+        const aTime = Date.parse(a.deletedAt || a.updatedAt || '') || 0;
+        const bTime = Date.parse(b.deletedAt || b.updatedAt || '') || 0;
+        return bTime - aTime;
+    });
+    const totalCount = items.length;
+    if (countOnly) {
+        return {
+            totalCount,
+            items: []
+        };
     }
-
-    const switchToProxy = params.switchToProxy !== false;
-    let targetModel = '';
-    if (switchToProxy) {
-        try {
-            targetModel = cmdSwitch(BUILTIN_PROXY_PROVIDER_NAME, true) || '';
-        } catch (e) {
-            return { error: `写入代理 provider 成功，但切换失败: ${e.message}` };
+    const visibleEntries = items.slice(0, limit);
+    const hydratedVisibleEntries = await hydrateSessionTrashEntries(visibleEntries, { source });
+    const updatedEntriesById = new Map();
+    for (let index = 0; index < visibleEntries.length; index += 1) {
+        const originalEntry = visibleEntries[index];
+        const hydratedEntry = hydratedVisibleEntries[index];
+        if (!originalEntry || !hydratedEntry) {
+            continue;
+        }
+        if (
+            originalEntry.messageCount !== hydratedEntry.messageCount
+            || originalEntry.messageCountMtimeMs !== hydratedEntry.messageCountMtimeMs
+        ) {
+            updatedEntriesById.set(originalEntry.trashId, hydratedEntry);
         }
     }
-
+    if (updatedEntriesById.size > 0) {
+        const latestEntries = readSessionTrashEntries({ cleanup: false });
+        writeSessionTrashEntries(latestEntries.map((entry) => updatedEntriesById.get(entry.trashId) || entry));
+    }
     return {
-        success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl,
-        switched: switchToProxy,
-        model: targetModel
+        totalCount,
+        items: hydratedVisibleEntries.map((item) => ({
+            ...item,
+            trashFilePath: resolveSessionTrashFilePath(item)
+        }))
     };
 }
 
-async function ensureBuiltinProxyForCodexDefault(params = {}) {
-    const payload = isPlainObject(params) ? { ...params } : {};
-    const switchToProxy = payload.switchToProxy !== false;
-    delete payload.switchToProxy;
-    payload.enabled = true;
-
-    const saveResult = saveBuiltinProxySettings(payload);
-    if (saveResult.error) {
-        return { error: saveResult.error };
+async function restoreSessionTrashItem(params = {}) {
+    const trashId = typeof params.trashId === 'string' ? params.trashId.trim() : '';
+    if (!trashId) {
+        return { error: '请先选择要恢复的回收站记录' };
     }
-    let nextSettings = saveResult.settings;
 
-    let upstreamResult = resolveBuiltinProxyUpstream(nextSettings);
-    if (upstreamResult.error) {
-        return { error: upstreamResult.error };
+    const entries = readSessionTrashEntries();
+    const entry = entries.find((item) => item.trashId === trashId);
+    if (!entry) {
+        return { error: '回收站记录不存在' };
+    }
+    const hydratedEntry = await resolveSessionTrashEntryExactMessageCount(entry);
+    if (!hydratedEntry) {
+        return { error: '回收站记录不存在' };
     }
 
-    const runtime = g_builtinProxyRuntime;
-    const shouldRestart = !!runtime && (
-        runtime.settings.host !== nextSettings.host
-        || runtime.settings.port !== nextSettings.port
-        || runtime.settings.authSource !== nextSettings.authSource
-        || runtime.settings.timeoutMs !== nextSettings.timeoutMs
-        || runtime.upstream.providerName !== upstreamResult.providerName
-        || runtime.upstream.baseUrl !== upstreamResult.baseUrl
-        || runtime.upstream.authHeader !== upstreamResult.authHeader
-    );
+    const trashFilePath = resolveSessionTrashFilePath(hydratedEntry);
+    if (!trashFilePath || !fs.existsSync(trashFilePath)) {
+        return { error: '回收站文件不存在' };
+    }
 
-    if (shouldRestart) {
-        await stopBuiltinProxyRuntime();
+    const targetFilePath = resolveSessionRestoreTarget(hydratedEntry);
+    if (!targetFilePath) {
+        return { error: '原始会话路径非法，无法恢复' };
+    }
+    if (fs.existsSync(targetFilePath)) {
+        return { error: '原始会话路径已存在同名文件，请先手动处理冲突' };
     }
 
-    if (!g_builtinProxyRuntime) {
-        let startRes = await startBuiltinProxyRuntime(nextSettings);
-        if (!startRes.success && /EADDRINUSE/i.test(String(startRes.error || ''))) {
-            const fallbackPort = await findAvailablePort(nextSettings.host, nextSettings.port + 1, 30);
-            if (fallbackPort > 0) {
-                const retrySave = saveBuiltinProxySettings({
-                    ...nextSettings,
-                    port: fallbackPort,
-                    enabled: true
-                });
-                if (retrySave.success) {
-                    nextSettings = retrySave.settings;
-                    upstreamResult = resolveBuiltinProxyUpstream(nextSettings);
-                    if (upstreamResult.error) {
-                        return { error: upstreamResult.error };
-                    }
-                    startRes = await startBuiltinProxyRuntime(nextSettings);
-                }
-            }
+    let claudeIndexPath = '';
+    try {
+        const latestEntries = readSessionTrashEntries({ cleanup: false });
+        const latestEntry = latestEntries.find((item) => item && item.trashId === trashId);
+        if (!latestEntry) {
+            return { error: '回收站记录不存在' };
+        }
+        const remainingEntries = latestEntries.filter((item) => item.trashId !== trashId);
+        moveFileSync(trashFilePath, targetFilePath);
+        if (hydratedEntry.source === 'claude') {
+            claudeIndexPath = resolveClaudeSessionRestoreIndexPath(hydratedEntry, targetFilePath);
+            upsertClaudeSessionIndexEntry(claudeIndexPath, targetFilePath, hydratedEntry);
+        }
+        writeSessionTrashEntries(remainingEntries);
+    } catch (e) {
+        let rollbackSucceeded = false;
+        if (fs.existsSync(targetFilePath) && !fs.existsSync(trashFilePath)) {
+            try {
+                moveFileSync(targetFilePath, trashFilePath);
+                rollbackSucceeded = true;
+            } catch (_) {}
         }
-        if (!startRes.success) {
-            return { error: startRes.error || '启动内建代理失败' };
+        if (rollbackSucceeded && entry.source === 'claude' && claudeIndexPath && fs.existsSync(claudeIndexPath)) {
+            try {
+                removeClaudeSessionIndexEntry(claudeIndexPath, targetFilePath, entry.sessionId);
+            } catch (_) {}
         }
+        return { error: `恢复会话失败: ${e.message}` };
     }
 
-    let applyRes = {
+    invalidateSessionListCache();
+
+    return {
         success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl: buildProxyListenUrl(nextSettings),
-        switched: false,
-        model: ''
+        restored: true,
+        trashId,
+        source: entry.source,
+        sessionId: entry.sessionId,
+        filePath: targetFilePath
     };
-    if (switchToProxy) {
-        applyRes = applyBuiltinProxyProvider({ switchToProxy: true });
-        if (applyRes.error) {
-            return applyRes;
+}
+
+async function purgeSessionTrashItems(params = {}) {
+    const entries = readSessionTrashEntries();
+    if (entries.length === 0) {
+        return { success: true, purged: [], count: 0 };
+    }
+
+    const all = params.all === true;
+    const trashIds = Array.isArray(params.trashIds)
+        ? params.trashIds
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter(Boolean)
+        : [];
+    const singleTrashId = typeof params.trashId === 'string' ? params.trashId.trim() : '';
+    const targetIds = all
+        ? new Set(entries.map((item) => item.trashId))
+        : new Set(singleTrashId ? [singleTrashId, ...trashIds] : trashIds);
+
+    if (targetIds.size === 0) {
+        return { error: '请先选择要彻底删除的回收站记录' };
+    }
+
+    const purged = [];
+    const remaining = [];
+    let purgeError = null;
+    for (let index = 0; index < entries.length; index += 1) {
+        const entry = entries[index];
+        if (!targetIds.has(entry.trashId)) {
+            remaining.push(entry);
+            continue;
         }
+        const trashFilePath = resolveSessionTrashFilePath(entry);
+        if (trashFilePath && fs.existsSync(trashFilePath)) {
+            try {
+                fs.unlinkSync(trashFilePath);
+            } catch (e) {
+                if (!purgeError) purgeError = e;
+                remaining.push(entry);
+                continue;
+            }
+        }
+        purged.push({
+            trashId: entry.trashId,
+            source: entry.source,
+            sessionId: entry.sessionId
+        });
+    }
+
+    try {
+        writeSessionTrashEntries(remaining);
+    } catch (e) {
+        return { error: `回收站索引更新失败: ${e.message}` };
+    }
+
+    if (purgeError) {
+        return { error: `彻底删除失败: ${purgeError.message}` };
     }
 
-    const status = getBuiltinProxyStatus();
     return {
         success: true,
-        provider: applyRes.provider,
-        baseUrl: applyRes.baseUrl,
-        switched: applyRes.switched,
-        model: applyRes.model || '',
-        settings: status.settings,
-        runtime: status.runtime
+        purged,
+        count: purged.length
     };
 }
 
-function updateClaudeSessionIndex(indexPath, sessionFilePath, sessionId) {
-    if (!indexPath || !fs.existsSync(indexPath)) {
-        return;
+async function trashSessionData(params = {}) {
+    const source = params.source === 'claude' ? 'claude' : (params.source === 'codex' ? 'codex' : '');
+    if (!source) {
+        return { error: 'Invalid source' };
     }
-    const index = readJsonFile(indexPath, null);
-    if (!index || !Array.isArray(index.entries)) {
-        return;
+
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
+    if (!filePath) {
+        return { error: 'Session file not found' };
     }
-    const resolvedFile = sessionFilePath ? path.resolve(sessionFilePath) : '';
-    const resolvedLower = resolvedFile ? resolvedFile.toLowerCase() : '';
-    const filtered = index.entries.filter((entry) => {
-        if (!entry || typeof entry !== 'object') {
-            return false;
+
+    const summary = (source === 'claude' ? parseClaudeSessionSummary(filePath) : parseCodexSessionSummary(filePath))
+        || buildSessionSummaryFallback(source, filePath, params.sessionId);
+    const exactMessageCount = await countConversationMessagesInFile(filePath, source);
+    if (Number.isFinite(Number(exactMessageCount))) {
+        summary.messageCount = Math.max(0, Math.floor(Number(exactMessageCount)));
+    }
+    const sessionId = summary.sessionId || params.sessionId || path.basename(filePath, '.jsonl');
+    const { trashId, trashFileName, trashFilePath } = allocateSessionTrashTarget();
+    const deletedAt = new Date().toISOString();
+    const claudeIndexPath = source === 'claude' ? findClaudeSessionIndexPath(filePath) : '';
+    let removedClaudeIndexEntry = null;
+
+    try {
+        moveFileSync(filePath, trashFilePath);
+    } catch (e) {
+        return { error: `移入回收站失败: ${e.message}` };
+    }
+
+    try {
+        if (source === 'claude' && claudeIndexPath) {
+            const removal = removeClaudeSessionIndexEntry(claudeIndexPath, filePath, sessionId);
+            removedClaudeIndexEntry = removal && removal.entry ? removal.entry : null;
+        }
+        const entry = buildSessionTrashEntry(summary, {
+            trashId,
+            trashFileName,
+            trashFilePath,
+            source,
+            sessionId,
+            deletedAt,
+            originalFilePath: filePath,
+            claudeIndexPath,
+            claudeIndexEntry: removedClaudeIndexEntry
+        });
+        const entries = readSessionTrashEntries({ cleanup: false });
+        const totalCount = entries.length + 1;
+        const nextEntries = [entry, ...entries].slice(0, MAX_SESSION_TRASH_LIST_SIZE);
+        writeSessionTrashEntries(nextEntries);
+        summary.totalCount = Math.min(totalCount, MAX_SESSION_TRASH_LIST_SIZE);
+    } catch (e) {
+        let rollbackSucceeded = false;
+        if (fs.existsSync(trashFilePath) && !fs.existsSync(filePath)) {
+            try {
+                moveFileSync(trashFilePath, filePath);
+                rollbackSucceeded = true;
+            } catch (_) {}
         }
-        const entrySessionId = typeof entry.sessionId === 'string' ? entry.sessionId : '';
-        if (sessionId && entrySessionId === sessionId) {
-            return false;
+        if (rollbackSucceeded && source === 'claude' && claudeIndexPath && removedClaudeIndexEntry) {
+            try {
+                upsertClaudeSessionIndexEntry(claudeIndexPath, filePath, {
+                    source,
+                    sessionId,
+                    title: summary.title,
+                    messageCount: summary.messageCount,
+                    capabilities: summary.capabilities,
+                    keywords: summary.keywords,
+                    updatedAt: summary.updatedAt,
+                    createdAt: summary.createdAt,
+                    claudeIndexEntry: removedClaudeIndexEntry,
+                    originalFilePath: filePath,
+                    trashId,
+                    trashFileName
+                });
+            } catch (_) {}
         }
-        if (entry.fullPath) {
-            const expanded = expandHomePath(entry.fullPath);
-            const entryPath = expanded ? path.resolve(expanded) : '';
-            if (entryPath && resolvedLower && entryPath.toLowerCase() === resolvedLower) {
-                return false;
-            }
+        if (!rollbackSucceeded && fs.existsSync(trashFilePath)) {
+            try { fs.unlinkSync(trashFilePath); } catch (_) {}
         }
-        return true;
-    });
-    if (filtered.length === index.entries.length) {
-        return;
+        return { error: `移入回收站失败: ${e.message}` };
     }
-    index.entries = filtered;
-    try {
-        fs.writeFileSync(indexPath, JSON.stringify(index, null, 2), 'utf-8');
-    } catch (e) {}
+
+    invalidateSessionListCache();
+
+    return {
+        success: true,
+        source,
+        sessionId,
+        filePath,
+        trashed: true,
+        trashId,
+        deletedAt,
+        totalCount: Number.isFinite(Number(summary && summary.totalCount))
+            ? Math.max(0, Math.floor(Number(summary.totalCount)))
+            : undefined,
+        messageCount: Number.isFinite(Number(summary && summary.messageCount))
+            ? Math.max(0, Math.floor(Number(summary.messageCount)))
+            : 0
+    };
 }
 
 async function deleteSessionData(params = {}) {
@@ -5231,14 +6650,16 @@ async function deleteSessionData(params = {}) {
         return { error: 'Invalid source' };
     }
 
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
     if (!filePath) {
         return { error: 'Session file not found' };
     }
 
     const sessionId = params.sessionId || path.basename(filePath, '.jsonl');
+    let fileDeleted = false;
     try {
         fs.unlinkSync(filePath);
+        fileDeleted = true;
     } catch (e) {
         return { error: `删除会话失败: ${e.message}` };
     }
@@ -5246,7 +6667,14 @@ async function deleteSessionData(params = {}) {
     if (source === 'claude') {
         const indexPath = findClaudeSessionIndexPath(filePath);
         if (indexPath) {
-            updateClaudeSessionIndex(indexPath, filePath, sessionId);
+            try {
+                removeClaudeSessionIndexEntry(indexPath, filePath, sessionId);
+            } catch (e) {
+                console.warn('删除会话索引失败:', e && e.message ? e.message : e);
+                if (!fileDeleted) {
+                    return { error: `删除会话失败: ${e.message || e}` };
+                }
+            }
         }
     }
 
@@ -5256,7 +6684,8 @@ async function deleteSessionData(params = {}) {
         success: true,
         source,
         sessionId,
-        filePath
+        filePath,
+        deleted: true
     };
 }
 
@@ -5311,7 +6740,7 @@ async function cloneCodexSession(params = {}) {
         return { error: '仅支持 Codex 会话克隆' };
     }
 
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
     if (!filePath) {
         return { error: 'Session file not found' };
     }
@@ -5690,26 +7119,26 @@ async function readSessionDetail(params = {}) {
         return { error: 'Invalid source' };
     }
 
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
     if (!filePath) {
         return { error: 'Session file not found' };
     }
 
-    const rawLimit = Number(params.messageLimit);
+    const rawMaxMessages = Number(params.maxMessages);
+    const rawLimit = Number.isFinite(rawMaxMessages) ? rawMaxMessages : Number(params.messageLimit);
     const messageLimit = Number.isFinite(rawLimit)
         ? Math.max(1, Math.min(rawLimit, MAX_SESSION_DETAIL_MESSAGES))
         : DEFAULT_SESSION_DETAIL_MESSAGES;
 
-    const extracted = await extractMessagesFromFile(filePath, source);
+    const extracted = await extractSessionDetailPreviewFromFile(filePath, source, messageLimit);
     const sessionId = extracted.sessionId || params.sessionId || path.basename(filePath, '.jsonl');
     const sourceLabel = source === 'codex' ? 'Codex' : 'Claude Code';
-    const allMessages = removeLeadingSystemMessage(Array.isArray(extracted.messages) ? extracted.messages : [])
-        .map((message, messageIndex) => ({
-            ...message,
-            messageIndex
-        }));
-    const startIndex = Math.max(0, allMessages.length - messageLimit);
-    const clippedMessages = allMessages.slice(startIndex);
+    const clippedMessages = Array.isArray(extracted.messages) ? extracted.messages : [];
+    const startIndex = Math.max(0, extracted.totalMessages - clippedMessages.length);
+    const indexedMessages = clippedMessages.map((message, messageIndex) => ({
+        ...message,
+        messageIndex: startIndex + messageIndex
+    }));
 
     return {
         source,
@@ -5717,10 +7146,10 @@ async function readSessionDetail(params = {}) {
         sessionId,
         cwd: extracted.cwd || '',
         updatedAt: extracted.updatedAt || '',
-        totalMessages: allMessages.length,
-        clipped: allMessages.length > clippedMessages.length,
+        totalMessages: extracted.totalMessages,
+        clipped: extracted.totalMessages > indexedMessages.length,
         messageLimit,
-        messages: clippedMessages,
+        messages: indexedMessages,
         filePath
     };
 }
@@ -5731,7 +7160,7 @@ async function readSessionPlain(params = {}) {
         return { error: 'Invalid source' };
     }
 
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
     if (!filePath) {
         return { error: 'Session file not found' };
     }
@@ -5777,7 +7206,7 @@ async function exportSessionData(params = {}) {
     }
 
     const maxMessages = resolveMaxMessagesValue(params.maxMessages, MAX_EXPORT_MESSAGES);
-    const filePath = resolveSessionFilePath(source, params.filePath, params.sessionId);
+    const filePath = resolveSessionFilePath(source, getSessionFileArg(params), params.sessionId);
     if (!filePath) {
         return { error: 'Session file not found' };
     }
@@ -6163,7 +7592,8 @@ async function cmdSetup() {
         const { config } = readConfigOrVirtualDefault();
         const providers = config.model_providers || {};
         const providerNames = Object.keys(providers);
-        const defaultProvider = config.model_provider || providerNames[0] || '';
+        const currentProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+        const defaultProvider = currentProvider || providerNames[0] || '';
         let availableModels = [];
         let defaultModel = config.model || '';
         let modelFetchUnlimited = false;
@@ -6449,7 +7879,7 @@ async function cmdModels() {
 
 // 切换提供商
 function cmdSwitch(providerName, silent = false) {
-    const config = readConfig();
+    const config = sanitizeRemovedBuiltinProxyProvider(readConfig());
     const providers = config.model_providers || {};
 
     if (!providers[providerName]) {
@@ -6552,6 +7982,10 @@ function cmdAdd(name, baseUrl, apiKey, silent = false) {
         if (!silent) console.error('错误: local provider 为系统保留名称，不可新增');
         throw new Error('local provider 为系统保留名称，不可新增');
     }
+    if (isBuiltinProxyProvider(providerName)) {
+        if (!silent) console.error('错误: codexmate-proxy 为保留名称，不可手动添加');
+        throw new Error('codexmate-proxy 为保留名称，不可手动添加');
+    }
 
     const config = readConfig();
     if (config.model_providers && config.model_providers[providerName]) {
@@ -6616,7 +8050,7 @@ function cmdUpdate(name, baseUrl, apiKey, silent = false, options = {}) {
     if (isNonEditableProvider(name) && !allowManaged) {
         const msg = isDefaultLocalProvider(name)
             ? 'local provider 为系统保留项，不可编辑'
-            : '本地代理配置为系统内建项，不可编辑';
+            : 'codexmate-proxy 为保留名称，不可编辑';
         if (!silent) console.error(`错误: ${msg}`);
         throw new Error(msg);
     }
@@ -8448,22 +9882,55 @@ function resolveUploadFileNameFromRequest(req, fallbackName = 'codex-skills.zip'
     return normalized || fallback;
 }
 
-async function handleImportCodexSkillsZipUpload(req, res) {
+function resolveSkillTargetAppFromRequest(req, fallbackApp = 'codex') {
+    const fallbackTarget = resolveSkillTarget({}, fallbackApp);
+    const fallback = fallbackTarget ? fallbackTarget.app : 'codex';
+    try {
+        const parsed = new URL(req.url || '/', 'http://localhost');
+        const hasTargetApp = parsed.searchParams.has('targetApp');
+        const hasTarget = parsed.searchParams.has('target');
+        if (hasTargetApp || hasTarget) {
+            const target = resolveSkillTarget({
+                ...(hasTargetApp ? { targetApp: parsed.searchParams.get('targetApp') } : {}),
+                ...(hasTarget ? { target: parsed.searchParams.get('target') } : {})
+            }, fallback);
+            return target ? target.app : null;
+        }
+        return fallback;
+    } catch (_) {
+        return fallback;
+    }
+}
+
+async function handleImportSkillsZipUpload(req, res, options = {}) {
     if (req.method !== 'POST') {
+        if (req && typeof req.resume === 'function') {
+            req.resume();
+        }
         writeJsonResponse(res, 405, { error: 'Method Not Allowed' });
         return;
     }
     try {
-        const fileName = resolveUploadFileNameFromRequest(req, 'codex-skills.zip');
+        const forcedTargetApp = normalizeSkillTargetApp(options && options.targetApp ? options.targetApp : '');
+        const targetApp = forcedTargetApp || resolveSkillTargetAppFromRequest(req, 'codex');
+        if (!targetApp) {
+            if (req && typeof req.resume === 'function') {
+                req.resume();
+            }
+            writeJsonResponse(res, 400, { error: '目标宿主不支持' });
+            return;
+        }
+        const fileName = resolveUploadFileNameFromRequest(req, `${targetApp}-skills.zip`);
         const upload = await writeUploadZipStream(
             req,
             'codex-skills-import',
             fileName,
             MAX_SKILLS_ZIP_UPLOAD_SIZE
         );
-        const result = await importCodexSkillsFromZipFile(upload.zipPath, {
+        const result = await importSkillsFromZipFile(upload.zipPath, {
             tempDir: upload.tempDir,
-            fallbackName: fileName
+            fallbackName: fileName,
+            targetApp
         });
         writeJsonResponse(res, 200, result || {});
     } catch (e) {
@@ -8477,14 +9944,33 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
 
     const server = http.createServer((req, res) => {
         const requestPath = (req.url || '/').split('?')[0];
+        if (requestPath === '/api/import-skills-zip') {
+            void handleImportSkillsZipUpload(req, res);
+            return;
+        }
         if (requestPath === '/api/import-codex-skills-zip') {
-            void handleImportCodexSkillsZipUpload(req, res);
+            void handleImportSkillsZipUpload(req, res, { targetApp: 'codex' });
             return;
         }
         if (requestPath === '/api') {
             let body = '';
-            req.on('data', chunk => body += chunk);
+            let bodySize = 0;
+            let bodyTooLarge = false;
+            req.on('data', chunk => {
+                if (bodyTooLarge) return;
+                bodySize += chunk.length;
+                if (bodySize > MAX_API_BODY_SIZE) {
+                    bodyTooLarge = true;
+                    writeJsonResponse(res, 413, {
+                        error: `请求体过大（>${Math.floor(MAX_API_BODY_SIZE / 1024 / 1024)}MB）`
+                    });
+                    req.destroy();
+                    return;
+                }
+                body += chunk;
+            });
             req.on('end', async () => {
+                if (bodyTooLarge) return;
                 try {
                     const { action, params } = JSON.parse(body);
                     let result;
@@ -8592,6 +10078,24 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'apply-agents-file':
                             result = applyAgentsFile(params || {});
                             break;
+                        case 'preview-agents-diff':
+                            result = buildAgentsDiff(params || {});
+                            break;
+                        case 'list-skills':
+                            result = listSkills(params || {});
+                            break;
+                        case 'delete-skills':
+                            result = deleteSkills(params || {});
+                            break;
+                        case 'scan-unmanaged-skills':
+                            result = scanUnmanagedSkills(params || {});
+                            break;
+                        case 'import-skills':
+                            result = importSkills(params || {});
+                            break;
+                        case 'export-skills':
+                            result = await exportSkills(params || {});
+                            break;
                         case 'list-codex-skills':
                             result = listCodexSkills();
                             break;
@@ -8679,7 +10183,7 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                                     result = { error: 'Invalid source. Must be codex, claude, or all' };
                                 } else {
                                     result = {
-                                        sessions: listAllSessions(params),
+                                        sessions: await listAllSessionsData(params),
                                         source: source || 'all'
                                     };
                                 }
@@ -8697,6 +10201,18 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                                 }
                             }
                             break;
+                        case 'list-session-trash':
+                            result = await listSessionTrashItems(params || {});
+                            break;
+                        case 'restore-session-trash':
+                            result = await restoreSessionTrashItem(params || {});
+                            break;
+                        case 'purge-session-trash':
+                            result = await purgeSessionTrashItems(params || {});
+                            break;
+                        case 'trash-session':
+                            result = await trashSessionData(params || {});
+                            break;
                         case 'export-session':
                             result = await exportSessionData(params);
                             break;
@@ -8939,7 +10455,9 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
         process.exit(1);
     });
 
-    const openHost = isAnyAddressHost(host) ? DEFAULT_WEB_HOST : host;
+    const openHost = host === '::'
+        ? '::1'
+        : (host === '0.0.0.0' ? DEFAULT_WEB_OPEN_HOST : host);
     const openUrl = `http://${formatHostForUrl(openHost)}:${port}`;
     server.listen(port, host, () => {
         console.log('\n✓ Web UI 已启动:', openUrl);
@@ -8995,6 +10513,69 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
     return { server, stop };
 }
 
+// Region markers are used by unit tests that extract these helpers directly.
+// #region createSerializedWebUiRestartHandler
+function createSerializedWebUiRestartHandler(runRestart) {
+    let restartQueued = false;
+    let latestRestartInfo = null;
+    let restartInFlight = null;
+
+    const drainRestartQueue = async () => {
+        try {
+            while (restartQueued) {
+                restartQueued = false;
+                await runRestart(latestRestartInfo);
+            }
+        } finally {
+            restartInFlight = null;
+            if (restartQueued) {
+                restartInFlight = drainRestartQueue();
+                return restartInFlight;
+            }
+        }
+    };
+
+    return (info) => {
+        latestRestartInfo = info;
+        restartQueued = true;
+        if (!restartInFlight) {
+            restartInFlight = drainRestartQueue();
+        }
+        return restartInFlight;
+    };
+}
+// #endregion createSerializedWebUiRestartHandler
+
+// #region restartWebUiServerAfterFrontendChange
+async function restartWebUiServerAfterFrontendChange({
+    serverHandle,
+    serverOptions,
+    createServer = createWebServer,
+    delayMs = 3000,
+    wait = setTimeout,
+    logger = console
+}) {
+    logger.log('  正在停止旧服务...');
+    try {
+        await serverHandle.stop();
+        logger.log('  旧服务已停止');
+    } catch (e) {
+        logger.warn('! 停止旧服务失败:', e.message || e);
+    }
+
+    await new Promise((resolve) => wait(resolve, delayMs));
+
+    try {
+        const nextServerHandle = await createServer(serverOptions);
+        logger.log('✓ 已重启 Web UI 服务\n');
+        return nextServerHandle;
+    } catch (e) {
+        logger.error('! 重启失败:', e.message || e);
+        return serverHandle;
+    }
+}
+// #endregion restartWebUiServerAfterFrontendChange
+
 // 打开 Web UI
 function cmdStart(options = {}) {
     const webDir = path.join(__dirname, 'web-ui');
@@ -9019,51 +10600,28 @@ function cmdStart(options = {}) {
         openBrowser: !options.noBrowser
     });
 
-    const proxySettings = readBuiltinProxySettings();
-    const shouldAutoStartProxy = proxySettings.enabled || hasCodexConfigReadyForProxy();
-    if (shouldAutoStartProxy) {
-        ensureBuiltinProxyForCodexDefault({
-            ...proxySettings,
-            switchToProxy: false
-        }).then((res) => {
-            if (res && res.success && res.runtime && res.runtime.listenUrl) {
-                const entryProvider = res.runtime.provider || DEFAULT_LOCAL_PROVIDER_NAME;
-                const upstreamLabel = res.runtime.upstreamProvider ? `（上游: ${res.runtime.upstreamProvider}）` : '';
-                console.log(`~ 内建代理已启动(${entryProvider}): ${res.runtime.listenUrl}${upstreamLabel}`);
-            } else if (res && res.error) {
-                console.warn(`! 内建代理启动失败: ${res.error}`);
-            }
-        }).catch((err) => {
-            console.warn(`! 内建代理启动失败: ${err && err.message ? err.message : err}`);
-        });
-    }
-
-    const stopWatch = watchPathsForRestart(
-        [webDir, legacyHtmlPath],
-        async (info) => {
+    const requestWebUiRestart = createSerializedWebUiRestartHandler(async (info) => {
             const fileLabel = info && info.filename ? info.filename : (info && info.target ? path.basename(info.target) : 'unknown');
             console.log(`\n~ 侦测到前端变更 (${fileLabel})，重启中...`);
-            console.log('  正在停止旧服务...');
-            try {
-                await serverHandle.stop();
-                console.log('  旧服务已停止');
-            } catch (e) {
-                console.warn('! 停止旧服务失败:', e.message || e);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 80));
-            try {
-                serverHandle = createWebServer({
+            serverHandle = await restartWebUiServerAfterFrontendChange({
+                serverHandle,
+                serverOptions: {
                     htmlPath,
                     assetsDir,
                     webDir,
                     host,
                     port,
                     openBrowser: false
-                });
-                console.log('✓ 已重启 Web UI 服务\n');
-            } catch (e) {
-                console.error('! 重启失败:', e.message || e);
-            }
+                }
+            });
+        });
+
+    const stopWatch = watchPathsForRestart(
+        [webDir, legacyHtmlPath],
+        (info) => {
+            void requestWebUiRestart(info).catch((err) => {
+                console.error('! 重启 Web UI 失败:', err && err.message ? err.message : err);
+            });
         }
     );
 
@@ -9233,111 +10791,8 @@ function parseProxyCliOptions(args = []) {
 }
 
 async function cmdProxy(args = []) {
-    const subcommand = (args[0] || 'status').toLowerCase();
-    const optionResult = parseProxyCliOptions(args.slice(1));
-    if (optionResult.error) {
-        throw new Error(optionResult.error);
-    }
-    const options = optionResult.payload || {};
-
-    if (subcommand === 'status') {
-        const status = getBuiltinProxyStatus();
-        const settings = status.settings || DEFAULT_BUILTIN_PROXY_SETTINGS;
-        console.log('\n内建代理状态:');
-        console.log('  运行中:', status.running ? '是' : '否');
-        console.log('  启用:', settings.enabled ? '是' : '否');
-        console.log('  监听:', buildProxyListenUrl(settings));
-        console.log('  上游 provider:', settings.provider || '(自动)');
-        console.log('  鉴权来源:', settings.authSource);
-        if (status.runtime) {
-            console.log('  实际上游:', status.runtime.upstreamProvider);
-            console.log('  启动时间:', status.runtime.startedAt);
-        }
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'set' || subcommand === 'config') {
-        const result = saveBuiltinProxySettings(options);
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        const settings = result.settings;
-        console.log('✓ 内建代理配置已保存');
-        console.log('  监听:', buildProxyListenUrl(settings));
-        console.log('  上游 provider:', settings.provider || '(自动)');
-        console.log('  鉴权来源:', settings.authSource);
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'apply' || subcommand === 'apply-provider') {
-        const result = applyBuiltinProxyProvider({
-            switchToProxy: options.switchToProxy !== false
-        });
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        console.log(`✓ 已写入本地代理 provider: ${result.provider}`);
-        console.log(`  URL: ${result.baseUrl}`);
-        if (result.switched) {
-            console.log(`  已切换到 ${result.provider}${result.model ? ` / ${result.model}` : ''}`);
-        }
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'enable' || subcommand === 'default-codex') {
-        const result = await ensureBuiltinProxyForCodexDefault(options);
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        const listenUrl = result.runtime && result.runtime.listenUrl
-            ? result.runtime.listenUrl
-            : buildProxyListenUrl(result.settings || DEFAULT_BUILTIN_PROXY_SETTINGS);
-        console.log('✓ 已启用 Codex 内建代理默认模式');
-        console.log(`  监听: ${listenUrl}`);
-        if (result.runtime && result.runtime.upstreamProvider) {
-            console.log(`  上游 provider: ${result.runtime.upstreamProvider}`);
-        }
-        console.log(`  当前 provider: ${result.provider}${result.model ? ` / ${result.model}` : ''}`);
-        console.log();
-        return;
-    }
-
-    if (subcommand === 'start') {
-        const result = await startBuiltinProxyRuntime({
-            ...options,
-            enabled: true
-        });
-        if (result.error) {
-            throw new Error(result.error);
-        }
-        console.log(`✓ 内建代理已启动: ${result.listenUrl}`);
-        console.log(`  上游 provider: ${result.upstreamProvider}`);
-        console.log('  按 Ctrl+C 停止代理\n');
-
-        await new Promise((resolve) => {
-            let stopping = false;
-            const gracefulStop = async () => {
-                if (stopping) return;
-                stopping = true;
-                await stopBuiltinProxyRuntime();
-                resolve();
-            };
-            process.once('SIGINT', gracefulStop);
-            process.once('SIGTERM', gracefulStop);
-        });
-        return;
-    }
-
-    if (subcommand === 'stop') {
-        await stopBuiltinProxyRuntime();
-        console.log('✓ 内建代理已停止\n');
-        return;
-    }
-
-    throw new Error(`未知 proxy 子命令: ${subcommand}`);
+    void args;
+    throw new Error('该功能已移除');
 }
 
 function parseWorkflowInputArg(rawInput) {
@@ -10389,7 +11844,7 @@ function createWorkflowToolCatalog() {
                 }
                 return {
                     source: source || 'all',
-                    sessions: listAllSessions({
+                    sessions: await listAllSessionsData({
                         ...args,
                         source: source || 'all'
                     })
@@ -10756,7 +12211,7 @@ function createMcpTools(options = {}) {
                 source: source || 'all'
             };
             return {
-                sessions: listAllSessions(normalizedInput),
+                sessions: await listAllSessionsData(normalizedInput),
                 source: source || 'all'
             };
         }
@@ -10992,18 +12447,34 @@ function createMcpTools(options = {}) {
         handler: async (args = {}) => applyOpenclawConfig(args || {})
     });
 
+    pushTool({
+        name: 'codexmate.session.trash',
+        description: 'Move one entire session file into session trash.',
+        readOnly: false,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string' },
+                sessionId: { type: 'string' },
+                filePath: { type: 'string' },
+                file: { type: 'string' }
+            },
+            additionalProperties: true
+        },
+        handler: async (args = {}) => trashSessionData(args || {})
+    });
+
     pushTool({
         name: 'codexmate.session.delete',
-        description: 'Delete one session or selected records in a session.',
+        description: 'Permanently delete one entire session file.',
         readOnly: false,
         inputSchema: {
             type: 'object',
             properties: {
                 source: { type: 'string' },
                 sessionId: { type: 'string' },
-                file: { type: 'string' },
-                recordLineIndex: { type: 'number' },
-                recordLineIndices: { type: 'array', items: { type: 'number' } }
+                filePath: { type: 'string' },
+                file: { type: 'string' }
             },
             additionalProperties: true
         },
@@ -11153,7 +12624,7 @@ function createMcpResources() {
                 }
                 const payload = {
                     source: normalizedSource || 'all',
-                    sessions: listAllSessions({
+                    sessions: await listAllSessionsData({
                         source: normalizedSource || 'all',
                         query,
                         pathFilter,
@@ -11395,11 +12866,9 @@ async function main() {
         console.log('  codexmate claude <BaseURL> <API密钥> [模型]  写入 Claude Code 配置');
         console.log('  codexmate add-model <模型> 添加模型');
         console.log('  codexmate delete-model <模型> 删除模型');
-        console.log('  codexmate auth <list|import|switch|delete|status>  认证文件管理');
-        console.log('  codexmate proxy <status|set|apply|enable|start|stop>  内建代理');
         console.log('  codexmate workflow <list|get|validate|run|runs>  MCP 工作流中心');
         console.log('  codexmate run [--host <HOST>] [--no-browser]    启动 Web 界面');
-        console.log('  codexmate codex [参数...] [--follow-up <文本>|--queued-follow-up <文本> 可重复]  等同于 codex --yolo（不会自动启用内建代理）');
+        console.log('  codexmate codex [参数...] [--follow-up <文本>|--queued-follow-up <文本> 可重复]  等同于 codex --yolo');
         console.log('    注: follow-up 自动排队仅支持 linux/android/netbsd/openbsd/darwin/freebsd 且 stdin 必须是 TTY，其他平台会报错');
         console.log('  codexmate qwen [参数...]   等同于 qwen --yolo');
         console.log('  codexmate mcp [serve] [--transport stdio] [--allow-write|--read-only]');