codexmate 0.0.18 → 0.0.20

package/cli.js

@@ -42,12 +42,15 @@ const { buildLineDiff } = require('./lib/text-diff');
 const {
     extractModelNames,
     hasModelsListPayload,
-    extractModelIds,
-    buildModelsProbeUrl,
+    buildModelsCacheKey,
     buildModelProbeSpec,
-    buildModelsCacheKey
+    buildModelConversationSpecs,
+    extractModelResponseText
 } = require('./lib/cli-models-utils');
-const { probeUrl, probeJsonPost } = require('./lib/cli-network-utils');
+const {
+    probeUrl,
+    probeJsonPost
+} = require('./lib/cli-network-utils');
 const {
     toIsoTime,
     updateLatestIso,
@@ -62,9 +65,17 @@ const {
     validateWorkflowDefinition,
     executeWorkflowDefinition
 } = require('./lib/workflow-engine');
+const { buildConfigHealthReport: buildConfigHealthReportCore } = require('./cli/config-health');
+const {
+    readBundledWebUiCss,
+    readBundledWebUiHtml,
+    readExecutableBundledJavaScriptModule,
+    readExecutableBundledWebUiScript
+} = require('./web-ui/source-bundle.cjs');
 
 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';
 
 // ============================================================================
 // 配置
@@ -92,11 +103,12 @@ const RECENT_CONFIGS_FILE = path.join(CONFIG_DIR, 'recent-configs.json');
 const WORKFLOW_DEFINITIONS_FILE = path.join(CONFIG_DIR, 'codexmate-workflows.json');
 const WORKFLOW_RUNS_FILE = path.join(CONFIG_DIR, 'codexmate-workflow-runs.jsonl');
 const DEFAULT_CLAUDE_MODEL = 'glm-4.7';
+const DEFAULT_MODEL_CONTEXT_WINDOW = 190000;
+const DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT = 185000;
 const CODEX_BACKUP_NAME = 'codex-config';
 
 const DEFAULT_MODELS = ['gpt-5.3-codex', 'gpt-5.1-codex-max', 'gpt-4-turbo', 'gpt-4'];
 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;
@@ -116,9 +128,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;
@@ -167,6 +183,48 @@ 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 joinPath = (basePath, ...segments) => {
+        const base = typeof basePath === 'string' ? basePath.trim() : '';
+        const pathApi = base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+        return pathApi.join(base, ...segments);
+    };
+    const envCodexHome = typeof process.env.CODEX_HOME === 'string' ? process.env.CODEX_HOME.trim() : '';
+    if (envCodexHome) {
+        const target = joinPath(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 = joinPath(xdgConfig, 'codex', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = joinPath(os.homedir(), '.config', 'codex', 'skills');
+    return resolveExistingDir([homeConfigDir], CODEX_SKILLS_DIR);
+}
+
+function getClaudeSkillsDir() {
+    const joinPath = (basePath, ...segments) => {
+        const base = typeof basePath === 'string' ? basePath.trim() : '';
+        const pathApi = base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+        return pathApi.join(base, ...segments);
+    };
+    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 = joinPath(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 = joinPath(xdgConfig, 'claude', 'skills');
+        return resolveExistingDir([target], target);
+    }
+    const homeConfigDir = joinPath(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;
@@ -175,6 +233,239 @@ function resolveWebPort() {
     return parsed;
 }
 
+// #region releaseRunPortIfNeeded
+function releaseRunPortIfNeeded(port, host, deps = {}) {
+    const numericPort = parseInt(String(port), 10);
+    if (numericPort !== DEFAULT_WEB_PORT) {
+        return { attempted: false, released: false, pids: [], reason: 'non-default-port' };
+    }
+
+    const processRef = deps.process || process;
+    const runSpawnSync = deps.spawnSync || spawnSync;
+    const logger = deps.logger || console;
+    const killProcess = typeof deps.kill === 'function'
+        ? deps.kill
+        : (typeof processRef.kill === 'function' ? processRef.kill.bind(processRef) : null);
+    const seenPids = new Set();
+    const candidatePids = new Set();
+    const currentPid = Number(processRef.pid);
+    const normalizedHost = typeof host === 'string' ? host.trim().toLowerCase() : '';
+    let released = false;
+    const windowsCommandLineCache = new Map();
+
+    const isManagedRunCommand = (commandLine) => {
+        const normalizedLine = ` ${String(commandLine || '').replace(/\s+/g, ' ').trim()} `;
+        return /(^|[\/\\\s])codexmate(?:\.cmd|\.exe)? run(\s|$)/i.test(normalizedLine)
+            || /(^|[\/\\\s])cli\.js run(\s|$)/i.test(normalizedLine);
+    };
+
+    const normalizeListenerHost = (value) => {
+        const trimmed = String(value || '').trim().toLowerCase();
+        if (!trimmed) {
+            return '';
+        }
+        if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+            return trimmed.slice(1, -1);
+        }
+        return trimmed.startsWith('::ffff:') ? trimmed.slice('::ffff:'.length) : trimmed;
+    };
+
+    const extractListenerHost = (localAddress) => {
+        const trimmed = String(localAddress || '').trim();
+        if (!trimmed) {
+            return '';
+        }
+        if (trimmed.startsWith('[')) {
+            const closingBracket = trimmed.indexOf(']');
+            if (closingBracket > 0) {
+                return normalizeListenerHost(trimmed.slice(1, closingBracket));
+            }
+        }
+        const lastColon = trimmed.lastIndexOf(':');
+        if (lastColon <= 0) {
+            return normalizeListenerHost(trimmed);
+        }
+        return normalizeListenerHost(trimmed.slice(0, lastColon));
+    };
+
+    const isMatchingWindowsListenerAddress = (localAddress) => {
+        const listenerHost = extractListenerHost(localAddress);
+        if (!listenerHost || !normalizedHost) {
+            return false;
+        }
+        if (normalizedHost === 'localhost') {
+            return listenerHost === '127.0.0.1' || listenerHost === '::1';
+        }
+        if (normalizedHost === '0.0.0.0' || normalizedHost === '::') {
+            return listenerHost === normalizedHost;
+        }
+        return listenerHost === normalizeListenerHost(normalizedHost);
+    };
+
+    const addPidsFromText = (text, targetSet = seenPids) => {
+        if (!targetSet) {
+            return;
+        }
+        const lines = String(text || '').split(/\r?\n/);
+        for (const line of lines) {
+            const tokens = line.trim().split(/\s+/).filter(Boolean);
+            for (const token of tokens) {
+                if (!/^\d+$/.test(token)) {
+                    continue;
+                }
+                targetSet.add(Number(token));
+            }
+        }
+    };
+
+    const runCommand = (command, args, options = {}) => {
+        const {
+            stdoutPidSet = seenPids,
+            stderrPidSet = seenPids
+        } = options;
+        const result = runSpawnSync(command, args, { encoding: 'utf8' });
+        if (result && result.stdout) addPidsFromText(result.stdout, stdoutPidSet);
+        if (result && result.stderr) addPidsFromText(result.stderr, stderrPidSet);
+        return result || {};
+    };
+
+    const addManagedRunPidsFromPs = (text, allowedPids = null) => {
+        const lines = String(text || '').split(/\r?\n/);
+        for (const line of lines) {
+            const normalizedLine = ` ${line.replace(/\s+/g, ' ').trim()} `;
+            if (!/(^|[\/\s])codexmate run(\s|$)/.test(normalizedLine) && !/(^|[\/\s])cli\.js run(\s|$)/.test(normalizedLine)) {
+                continue;
+            }
+            const pidMatch = line.match(/^\S+\s+(\d+)\s+/);
+            if (!pidMatch) {
+                continue;
+            }
+            const pid = Number(pidMatch[1]);
+            if (!Number.isFinite(pid) || pid <= 0 || pid === currentPid) {
+                continue;
+            }
+            if (allowedPids && !allowedPids.has(pid)) {
+                continue;
+            }
+            seenPids.add(pid);
+        }
+    };
+
+    const getWindowsProcessCommandLine = (pid) => {
+        if (windowsCommandLineCache.has(pid)) {
+            return windowsCommandLineCache.get(pid);
+        }
+        const result = runCommand(
+            'powershell',
+            [
+                '-NoProfile',
+                '-Command',
+                `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($p) { $p.CommandLine }`
+            ],
+            { stdoutPidSet: null, stderrPidSet: null }
+        );
+        const commandLine = !result.error && result.status === 0
+            ? String(result.stdout || '').trim()
+            : '';
+        windowsCommandLineCache.set(pid, commandLine);
+        return commandLine;
+    };
+
+    if (processRef.platform === 'win32') {
+        const netstatResult = runCommand('netstat', ['-ano', '-p', 'tcp'], { stdoutPidSet: null, stderrPidSet: null });
+        if (!(netstatResult && netstatResult.error)) {
+            const lines = String(netstatResult.stdout || '').split(/\r?\n/);
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                if (parts.length < 5) {
+                    continue;
+                }
+                const localAddress = parts[1];
+                const state = parts[3];
+                const pidText = parts[4];
+                if (state !== 'LISTENING' || !localAddress.endsWith(`:${numericPort}`) || !/^\d+$/.test(pidText)) {
+                    continue;
+                }
+                if (!isMatchingWindowsListenerAddress(localAddress)) {
+                    continue;
+                }
+                candidatePids.add(Number(pidText));
+            }
+            for (const pid of candidatePids) {
+                if (pid === currentPid) {
+                    continue;
+                }
+                if (!isManagedRunCommand(getWindowsProcessCommandLine(pid))) {
+                    continue;
+                }
+                seenPids.add(pid);
+                const taskkillResult = runCommand(
+                    'taskkill',
+                    ['/PID', String(pid), '/F'],
+                    { stdoutPidSet: null, stderrPidSet: null }
+                );
+                if (!taskkillResult.error && taskkillResult.status === 0) {
+                    released = true;
+                }
+            }
+        }
+    } else {
+        let psResult = null;
+        const readPsResult = () => {
+            if (psResult) {
+                return psResult;
+            }
+            psResult = runCommand('ps', ['-ef'], { stdoutPidSet: null, stderrPidSet: null });
+            return psResult;
+        };
+
+        const lsofResult = runCommand(
+            'lsof',
+            ['-ti', `tcp:${numericPort}`],
+            { stdoutPidSet: candidatePids, stderrPidSet: null }
+        );
+        const shouldTryFuser = !!(lsofResult && lsofResult.error && lsofResult.error.code === 'ENOENT');
+        if (shouldTryFuser && candidatePids.size === 0) {
+            runCommand(
+                'fuser',
+                [`${numericPort}/tcp`],
+                { stdoutPidSet: candidatePids, stderrPidSet: candidatePids }
+            );
+        }
+        if (candidatePids.size > 0) {
+            const managedPsResult = readPsResult();
+            if (!(managedPsResult && managedPsResult.error)) {
+                addManagedRunPidsFromPs(managedPsResult.stdout, candidatePids);
+            }
+        }
+    }
+
+    if (processRef.platform !== 'win32' && killProcess && !released && seenPids.size > 0) {
+        for (const pid of seenPids) {
+            if (pid === currentPid) {
+                continue;
+            }
+            try {
+                killProcess(pid, 'SIGKILL');
+                released = true;
+            } catch (_) {}
+        }
+    }
+
+    if (released) {
+        logger.log(`~ 已释放端口 ${numericPort} 占用`);
+    }
+
+    return {
+        attempted: true,
+        released,
+        pids: Array.from(seenPids)
+            .filter((pid) => pid !== currentPid)
+            .sort((a, b) => a - b)
+    };
+}
+// #endregion releaseRunPortIfNeeded
+
 function resolveWebHost(options = {}) {
     const optionHost = typeof options.host === 'string' ? options.host.trim() : '';
     if (optionHost) {
@@ -188,7 +479,8 @@ function resolveWebHost(options = {}) {
 }
 
 const EMPTY_CONFIG_FALLBACK_TEMPLATE = `model = "gpt-5.3-codex"
-model_reasoning_effort = "high"
+model_context_window = ${DEFAULT_MODEL_CONTEXT_WINDOW}
+model_auto_compact_token_limit = ${DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT}
 disable_response_storage = true
 approval_policy = "never"
 sandbox_mode = "danger-full-access"
@@ -216,7 +508,7 @@ 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) {
@@ -889,12 +1181,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));
 }
 
@@ -953,6 +1251,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 || '');
@@ -1042,6 +1341,7 @@ function importAuthProfileFromUpload(payload = {}) {
 }
 
 function switchAuthProfile(name, options = {}) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         throw new Error('认证名称不能为空');
@@ -1087,6 +1387,7 @@ function switchAuthProfile(name, options = {}) {
 }
 
 function deleteAuthProfile(name) {
+    ensureAuthProfileStoragePrepared();
     const profileName = normalizeAuthProfileName(name);
     if (!profileName) {
         return { error: '认证名称不能为空' };
@@ -1135,6 +1436,7 @@ function deleteAuthProfile(name) {
 }
 
 function resolveAuthTokenFromCurrentProfile() {
+    ensureAuthProfileStoragePrepared();
     const registry = readAuthRegistry();
     if (!registry.current) return '';
     const profile = registry.items.find((item) => item.name === registry.current);
@@ -1390,8 +1692,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();
@@ -1560,13 +1894,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;
     }
@@ -1577,7 +1911,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);
@@ -1595,26 +1929,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
         };
@@ -1623,6 +1965,10 @@ function listCodexSkills() {
     }
 }
 
+function listCodexSkills() {
+    return listSkills({ targetApp: 'codex' });
+}
+
 function listSkillEntriesByRoot(rootDir) {
     if (!rootDir || !fs.existsSync(rootDir)) {
         return [];
@@ -1668,8 +2014,18 @@ function listSkillEntriesByRoot(rootDir) {
     }
 }
 
-function scanUnmanagedCodexSkills() {
-    const existing = listCodexSkills();
+function scanUnmanagedSkills(params = {}) {
+    const getPathApi = (basePath) => {
+        const base = typeof basePath === 'string' ? basePath.trim() : '';
+        return base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+    };
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
+    const targetPathApi = getPathApi(targetRoot);
+    const existing = listSkills({ targetApp: target.app });
     if (existing.error) {
         return { error: existing.error };
     }
@@ -1677,10 +2033,15 @@ function scanUnmanagedCodexSkills() {
         .map((item) => (item && typeof item.name === 'string' ? item.name.trim() : ''))
         .filter(Boolean));
 
-    const items = [];
-    for (const source of SKILL_IMPORT_SOURCES) {
-        const sourceEntries = listSkillEntriesByRoot(source.dir);
-        for (const entry of sourceEntries) {
+    const items = [];
+    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 = targetPathApi.join(targetRoot, entry.name);
+            if (fs.existsSync(targetCandidate)) {
+                continue;
+            }
             if (existingNames.has(entry.name)) {
                 continue;
             }
@@ -1706,9 +2067,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,
@@ -1717,14 +2080,26 @@ function scanUnmanagedCodexSkills() {
     };
 }
 
-function importCodexSkills(params = {}) {
-    const rawItems = Array.isArray(params.items) ? params.items : [];
+function scanUnmanagedCodexSkills() {
+    return scanUnmanagedSkills({ targetApp: 'codex' });
+}
+
+function importSkills(params = {}) {
+    const getPathApi = (basePath) => {
+        const base = typeof basePath === 'string' ? basePath.trim() : '';
+        return base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+    };
+    const target = resolveSkillTarget(params);
+    if (!target) {
+        return { error: '目标宿主不支持' };
+    }
+    const targetRoot = resolveCopyTargetRoot(target.dir);
+    const targetPathApi = getPathApi(targetRoot);
+    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();
@@ -1749,18 +2124,27 @@ 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;
         }
         dedup.add(dedupKey);
 
-        const sourcePath = path.join(source.dir, normalizedName.name);
-        const sourceRelative = path.relative(source.dir, sourcePath);
-        if (sourceRelative.startsWith('..') || path.isAbsolute(sourceRelative)) {
-            failed.push({
-                name: normalizedName.name,
-                sourceApp: source.app,
+        const sourcePathApi = getPathApi(source.dir);
+        const sourcePath = sourcePathApi.join(source.dir, normalizedName.name);
+        const sourceRelative = sourcePathApi.relative(source.dir, sourcePath);
+        if (sourceRelative.startsWith('..') || sourcePathApi.isAbsolute(sourceRelative)) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
                 error: '来源路径非法'
             });
             continue;
@@ -1774,12 +2158,12 @@ function importCodexSkills(params = {}) {
             continue;
         }
 
-        const targetPath = path.join(CODEX_SKILLS_DIR, normalizedName.name);
-        const targetRelative = path.relative(CODEX_SKILLS_DIR, targetPath);
-        if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
-            failed.push({
-                name: normalizedName.name,
-                sourceApp: source.app,
+        const targetPath = targetPathApi.join(targetRoot, normalizedName.name);
+        const targetRelative = targetPathApi.relative(targetRoot, targetPath);
+        if (targetRelative.startsWith('..') || targetPathApi.isAbsolute(targetRelative)) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
                 error: '目标路径非法'
             });
             continue;
@@ -1788,7 +2172,7 @@ function importCodexSkills(params = {}) {
             failed.push({
                 name: normalizedName.name,
                 sourceApp: source.app,
-                error: 'Codex 中已存在同名 skill'
+                error: `${target.label} 中已存在同名 skill`
             });
             continue;
         }
@@ -1814,6 +2198,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,
@@ -1825,6 +2218,8 @@ function importCodexSkills(params = {}) {
                 name: normalizedName.name,
                 sourceApp: source.app,
                 sourceLabel: source.label,
+                targetApp: target.app,
+                targetLabel: target.label,
                 path: targetPath
             });
         } catch (e) {
@@ -1845,10 +2240,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;
@@ -1902,18 +2303,32 @@ function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbac
     return normalizeCodexSkillName(candidate);
 }
 
-async function importCodexSkillsFromZipFile(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');
+async function importSkillsFromZipFile(zipPath, options = {}) {
+    const getPathApi = (basePath) => {
+        const base = typeof basePath === 'string' ? basePath.trim() : '';
+        return base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+    };
+    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 extractionPathApi = getPathApi(tempDir || zipPath);
+    const extractionBaseDir = tempDir || extractionPathApi.dirname(zipPath);
+    const extractionRoot = extractionPathApi.join(extractionBaseDir, 'extract');
+    let target = null;
+    let targetRoot = '';
 
     try {
-        await inspectZipArchiveLimits(zipPath, {
-            maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
-            maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
+        target = resolveSkillTarget(options, 'codex');
+        if (!target) {
+            return { error: '目标宿主不支持' };
+        }
+        targetRoot = resolveCopyTargetRoot(target.dir);
+        const targetPathApi = getPathApi(targetRoot);
+        await inspectZipArchiveLimits(zipPath, {
+            maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
+            maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
         });
 
         await extractUploadZip(zipPath, extractionRoot);
@@ -1926,7 +2341,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) {
@@ -1942,19 +2356,19 @@ 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);
-            if (targetRelative.startsWith('..') || path.isAbsolute(targetRelative)) {
-                failed.push({
-                    name: normalizedName.name,
-                    error: '目标路径非法'
+            const targetPath = targetPathApi.join(targetRoot, normalizedName.name);
+            const targetRelative = targetPathApi.relative(targetRoot, targetPath);
+            if (targetRelative.startsWith('..') || targetPathApi.isAbsolute(targetRelative)) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: '目标路径非法'
                 });
                 continue;
             }
             if (fs.existsSync(targetPath)) {
                 failed.push({
                     name: normalizedName.name,
-                    error: 'Codex 中已存在同名 skill'
+                    error: `${target.label} 中已存在同名 skill`
                 });
                 continue;
             }
@@ -1970,6 +2384,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,
@@ -1979,6 +2401,8 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 copiedToTarget = true;
                 imported.push({
                     name: normalizedName.name,
+                    targetApp: target.app,
+                    targetLabel: target.label,
                     path: targetPath
                 });
             } catch (e) {
@@ -1999,7 +2423,9 @@ async function importCodexSkillsFromZipFile(zipPath, options = {}) {
                 error: failed[0].error || '导入失败',
                 imported,
                 failed,
-                root: CODEX_SKILLS_DIR
+                targetApp: target.app,
+                targetLabel: target.label,
+                root: targetRoot
             };
         }
 
@@ -2007,7 +2433,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 {
@@ -2026,21 +2454,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() : ''))
@@ -2062,8 +2509,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;
@@ -2109,12 +2556,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 {
@@ -2133,14 +2582,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 {
@@ -2149,6 +2602,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 });
@@ -2157,7 +2614,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() : ''))
@@ -2175,8 +2636,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;
@@ -2206,10 +2667,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);
@@ -2613,393 +3080,77 @@ function recordRecentConfig(provider, model) {
     writeRecentConfigs(trimmed);
 }
 
-async function runRemoteHealthCheck(provider, modelName, options = {}) {
-    const issues = [];
-    const results = {};
-    const baseUrl = normalizeBaseUrl(provider && provider.base_url ? provider.base_url : '');
-    if (!baseUrl) {
-        issues.push({
-            code: 'remote-skip-base-url',
-            message: '无法进行远程探测：base_url 为空',
-            suggestion: '补全 base_url 或关闭远程探测'
-        });
-        return { issues, results };
-    }
+async function buildConfigHealthReport(params = {}) {
+    return buildConfigHealthReportCore(params, {
+        readConfigOrVirtualDefault,
+        readModels
+    });
+}
 
-    const requiresAuth = provider && provider.requires_openai_auth !== false;
-    const apiKey = typeof provider.preferred_auth_method === 'string'
-        ? provider.preferred_auth_method.trim()
-        : '';
-    const authValue = requiresAuth ? apiKey : (apiKey || '');
-    const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : HEALTH_CHECK_TIMEOUT_MS;
-
-    const baseProbe = await probeUrl(baseUrl, { apiKey: authValue, timeoutMs });
-    results.base = {
-        url: baseUrl,
-        status: baseProbe.status || 0,
-        ok: baseProbe.ok,
-        durationMs: baseProbe.durationMs || 0
-    };
+function buildDefaultConfigContent(initializedAt) {
+    const defaultModel = DEFAULT_MODELS[0] || 'gpt-4';
+    return `${CODEXMATE_MANAGED_MARKER}
+# codexmate-initialized-at: ${initializedAt}
 
-    if (!baseProbe.ok) {
-        issues.push({
-            code: 'remote-unreachable',
-            message: `远程探测失败：${baseProbe.error || '无法连接'}`,
-            suggestion: '检查网络与 base_url 可达性'
-        });
-        return { issues, results };
-    }
+model_provider = "openai"
+model = "${defaultModel}"
+model_context_window = ${DEFAULT_MODEL_CONTEXT_WINDOW}
+model_auto_compact_token_limit = ${DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT}
 
-    if (baseProbe.status === 401 || baseProbe.status === 403) {
-        issues.push({
-            code: 'remote-auth-failed',
-            message: '远程探测鉴权失败（401/403）',
-            suggestion: '检查 API Key 或认证方式'
-        });
-    } else if (baseProbe.status >= 400) {
-        issues.push({
-            code: 'remote-http-error',
-            message: `远程探测返回异常状态: ${baseProbe.status}`,
-            suggestion: '检查 base_url 是否正确'
-        });
-    }
+[model_providers.openai]
+name = "openai"
+base_url = "https://api.openai.com/v1"
+wire_api = "responses"
+requires_openai_auth = false
+preferred_auth_method = ""
+request_max_retries = 4
+stream_max_retries = 10
+stream_idle_timeout_ms = 300000
+`;
+}
 
-    const modelsUrl = buildModelsProbeUrl(baseUrl);
-    if (modelsUrl) {
-        const modelsProbe = await probeUrl(modelsUrl, { apiKey: authValue, timeoutMs, maxBytes: 256 * 1024 });
-        results.models = {
-            url: modelsUrl,
-            status: modelsProbe.status || 0,
-            ok: modelsProbe.ok,
-            durationMs: modelsProbe.durationMs || 0
-        };
+function buildVirtualDefaultConfig() {
+    return toml.parse(EMPTY_CONFIG_FALLBACK_TEMPLATE);
+}
 
-        if (!modelsProbe.ok) {
-            issues.push({
-                code: 'remote-models-unreachable',
-                message: `模型列表探测失败：${modelsProbe.error || '无法连接'}`,
-                suggestion: '检查 base_url 是否包含 /v1 或关闭远程探测'
-            });
-        } else if (modelsProbe.status === 401 || modelsProbe.status === 403) {
-            issues.push({
-                code: 'remote-models-auth-failed',
-                message: '模型列表鉴权失败（401/403）',
-                suggestion: '检查 API Key 或认证方式'
-            });
-        } else if (modelsProbe.status >= 400) {
-            issues.push({
-                code: 'remote-models-http-error',
-                message: `模型列表返回异常状态: ${modelsProbe.status}`,
-                suggestion: '确认 /v1/models 可用'
-            });
-        } else {
-            let payload = null;
-            try {
-                payload = modelsProbe.body ? JSON.parse(modelsProbe.body) : null;
-            } catch (e) {
-                issues.push({
-                    code: 'remote-models-parse',
-                    message: '模型列表解析失败（非 JSON）',
-                    suggestion: '确认 /v1/models 返回 JSON'
-                });
-            }
+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 (payload) {
-                const ids = extractModelIds(payload);
-                if (ids.length === 0) {
-                    issues.push({
-                        code: 'remote-models-empty',
-                        message: '模型列表为空或结构无法识别',
-                        suggestion: '确认 provider 是否兼容 /v1/models'
-                    });
-                } else if (modelName && !ids.includes(modelName)) {
-                    issues.push({
-                        code: 'remote-model-unavailable',
-                        message: `远程模型列表中未找到: ${modelName}`,
-                        suggestion: '切换模型或确认模型名称'
-                    });
-                }
-            }
-        }
+    if (!hasRemovedBuiltin && !currentIsRemovedBuiltin) {
+        return safeConfig;
     }
 
-    const modelProbeSpec = buildModelProbeSpec(provider, modelName, baseUrl);
-    if (modelProbeSpec && modelProbeSpec.url) {
-        const modelProbe = await probeJsonPost(modelProbeSpec.url, modelProbeSpec.body, {
-            apiKey: authValue,
-            timeoutMs,
-            maxBytes: 256 * 1024
-        });
-
-        results.modelProbe = {
-            url: modelProbeSpec.url,
-            status: modelProbe.status || 0,
-            ok: modelProbe.ok,
-            durationMs: modelProbe.durationMs || 0
-        };
-
-        if (!modelProbe.ok) {
-            issues.push({
-                code: 'remote-model-probe-unreachable',
-                message: `模型可用性探测失败：${modelProbe.error || '无法连接'}`,
-                suggestion: '检查网络或模型接口是否可用'
-            });
-        } else if (modelProbe.status === 401 || modelProbe.status === 403) {
-            issues.push({
-                code: 'remote-model-probe-auth-failed',
-                message: '模型可用性探测鉴权失败（401/403）',
-                suggestion: '检查 API Key 或认证方式'
-            });
-        } else if (modelProbe.status >= 400) {
-            issues.push({
-                code: 'remote-model-probe-http-error',
-                message: `模型可用性探测返回异常状态: ${modelProbe.status}`,
-                suggestion: '检查模型或接口路径'
-            });
-        } else {
-            let payload = null;
-            try {
-                payload = modelProbe.body ? JSON.parse(modelProbe.body) : null;
-            } catch (e) {
-                issues.push({
-                    code: 'remote-model-probe-parse',
-                    message: '模型可用性探测解析失败（非 JSON）',
-                    suggestion: '确认模型接口返回 JSON'
-                });
-            }
-            if (payload && payload.error) {
-                const message = typeof payload.error.message === 'string'
-                    ? payload.error.message
-                    : '模型接口返回错误';
-                issues.push({
-                    code: 'remote-model-probe-error',
-                    message: `模型可用性探测失败：${message}`,
-                    suggestion: '检查模型名与权限'
-                });
-            }
-        }
-    }
+    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 { issues, results };
+    return {
+        ...safeConfig,
+        model_providers: nextProviders,
+        model_provider: currentIsRemovedBuiltin ? fallbackProvider : safeConfig.model_provider,
+        model: currentIsRemovedBuiltin ? fallbackModel : safeConfig.model
+    };
 }
 
-async function buildConfigHealthReport(params = {}) {
-    const issues = [];
-    const status = readConfigOrVirtualDefault();
-    const config = status.config || {};
-
-    if (status.isVirtual) {
-        const parseFailed = status.errorType === 'parse';
-        const readFailed = status.errorType === 'read';
-        issues.push({
-            code: parseFailed ? 'config-parse-failed' : (readFailed ? 'config-read-failed' : 'config-missing'),
-            message: status.reason || (parseFailed
-                ? 'config.toml 解析失败'
-                : (readFailed ? '读取 config.toml 失败' : '未检测到 config.toml')),
-            suggestion: parseFailed
-                ? '修复 config.toml 语法错误后重试'
-                : (readFailed ? '检查文件权限后重试' : '在模板编辑器中确认应用配置，生成可用的 config.toml')
-        });
-        if (parseFailed || readFailed) {
+function readConfigOrVirtualDefault() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            removePersistedBuiltinProxyProviderFromConfig();
             return {
-                ok: false,
-                issues,
-                summary: {
-                    currentProvider: '',
-                    currentModel: ''
-                },
-                remote: null
-            };
-        }
-    }
-
-    const providerName = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
-    const modelName = typeof config.model === 'string' ? config.model.trim() : '';
-    if (!providerName) {
-        issues.push({
-            code: 'provider-missing',
-            message: '当前 provider 未设置',
-            suggestion: '在模板中设置 model_provider'
-        });
-    }
-
-    if (!modelName) {
-        issues.push({
-            code: 'model-missing',
-            message: '当前模型未设置',
-            suggestion: '在模板中设置 model'
-        });
-    }
-
-    const providers = config.model_providers && typeof config.model_providers === 'object'
-        ? config.model_providers
-        : {};
-    const provider = providerName ? providers[providerName] : null;
-    if (providerName && !provider) {
-        issues.push({
-            code: 'provider-not-found',
-            message: `当前 provider 未在配置中找到: ${providerName}`,
-            suggestion: '检查 model_providers 是否包含该 provider 配置块'
-        });
-    }
-
-    if (provider && typeof provider === 'object') {
-        const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
-        if (!isValidHttpUrl(baseUrl)) {
-            issues.push({
-                code: 'base-url-invalid',
-                message: '当前 provider 的 base_url 无效',
-                suggestion: '请设置为 http/https 的完整 URL'
-            });
-        }
-
-        const requiresAuth = provider.requires_openai_auth;
-        if (requiresAuth !== false) {
-            const apiKey = typeof provider.preferred_auth_method === 'string'
-                ? provider.preferred_auth_method.trim()
-                : '';
-            if (!apiKey) {
-                issues.push({
-                    code: 'api-key-missing',
-                    message: '当前 provider 未配置 API Key',
-                    suggestion: '在模板中设置 preferred_auth_method'
-                });
-            }
-        }
-    }
-
-    if (modelName) {
-        const models = readModels();
-        if (!models.includes(modelName)) {
-            issues.push({
-                code: 'model-unavailable',
-                message: `模型未在可用列表中找到: ${modelName}`,
-                suggestion: '在模型列表中添加该模型或切换到已有模型'
-            });
-        }
-    }
-
-    const remoteEnabled = !!params.remote;
-    let remote = null;
-    if (remoteEnabled) {
-        const baseUrl = provider && typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
-        if (!provider) {
-            issues.push({
-                code: 'remote-skip-provider',
-                message: '无法进行远程探测：provider 未找到',
-                suggestion: '检查 model_provider 配置或关闭远程探测'
-            });
-        } else if (!isValidHttpUrl(baseUrl)) {
-            issues.push({
-                code: 'remote-skip-base-url',
-                message: '无法进行远程探测：base_url 无效',
-                suggestion: '补全 base_url 或关闭远程探测'
-            });
-        } else {
-            const timeoutMs = Number.isFinite(params.timeoutMs)
-                ? Math.max(1000, Number(params.timeoutMs))
-                : undefined;
-            const apiKey = typeof provider.preferred_auth_method === 'string'
-                ? provider.preferred_auth_method.trim()
-                : '';
-            const speedResult = await runSpeedTest(baseUrl, apiKey, { timeoutMs });
-            const status = speedResult && typeof speedResult.status === 'number'
-                ? speedResult.status
-                : 0;
-            const durationMs = speedResult && typeof speedResult.durationMs === 'number'
-                ? speedResult.durationMs
-                : 0;
-            const error = speedResult && speedResult.error ? String(speedResult.error) : '';
-            remote = {
-                type: 'speed-test',
-                url: baseUrl,
-                ok: !!speedResult.ok,
-                status,
-                durationMs,
-                error
-            };
-
-            if (!speedResult.ok) {
-                const errorLower = error.toLowerCase();
-                if (errorLower.includes('timeout')) {
-                    issues.push({
-                        code: 'remote-speedtest-timeout',
-                        message: '远程测速超时',
-                        suggestion: '检查网络或 base_url 是否可达'
-                    });
-                } else if (errorLower.includes('invalid url')) {
-                    issues.push({
-                        code: 'remote-speedtest-invalid-url',
-                        message: '远程测速失败：base_url 无效',
-                        suggestion: '请设置为 http/https 的完整 URL'
-                    });
-                } else {
-                    issues.push({
-                        code: 'remote-speedtest-unreachable',
-                        message: `远程测速失败：${error || '无法连接'}`,
-                        suggestion: '检查网络或 base_url 是否可用'
-                    });
-                }
-            } else if (status === 401 || status === 403) {
-                issues.push({
-                    code: 'remote-speedtest-auth-failed',
-                    message: '远程测速鉴权失败（401/403）',
-                    suggestion: '检查 API Key 或认证方式'
-                });
-            } else if (status >= 400) {
-                issues.push({
-                    code: 'remote-speedtest-http-error',
-                    message: `远程测速返回异常状态: ${status}`,
-                    suggestion: '检查 base_url 或服务状态'
-                });
-            }
-        }
-    }
-
-    return {
-        ok: issues.length === 0,
-        issues,
-        summary: {
-            currentProvider: providerName,
-            currentModel: modelName
-        },
-        remote
-    };
-}
-
-function buildDefaultConfigContent(initializedAt) {
-    const defaultModel = DEFAULT_MODELS[0] || 'gpt-4';
-    return `${CODEXMATE_MANAGED_MARKER}
-# codexmate-initialized-at: ${initializedAt}
-
-model_provider = "openai"
-model = "${defaultModel}"
-
-[model_providers.openai]
-name = "openai"
-base_url = "https://api.openai.com/v1"
-wire_api = "responses"
-requires_openai_auth = false
-preferred_auth_method = ""
-request_max_retries = 4
-stream_max_retries = 10
-stream_idle_timeout_ms = 300000
-`;
-}
-
-function buildVirtualDefaultConfig() {
-    return toml.parse(EMPTY_CONFIG_FALLBACK_TEMPLATE);
-}
-
-function readConfigOrVirtualDefault() {
-    if (fs.existsSync(CONFIG_FILE)) {
-        try {
-            return {
-                config: readConfig(),
-                isVirtual: false,
-                reason: '',
-                detail: '',
-                errorType: ''
+                config: sanitizeRemovedBuiltinProxyProvider(readConfig()),
+                isVirtual: false,
+                reason: '',
+                detail: '',
+                errorType: ''
             };
         } catch (e) {
             const errorType = typeof e.configErrorType === 'string' && e.configErrorType.trim()
@@ -3012,7 +3163,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,
@@ -3022,7 +3175,7 @@ function readConfigOrVirtualDefault() {
     }
 
     return {
-        config: buildVirtualDefaultConfig(),
+        config: sanitizeRemovedBuiltinProxyProvider(buildVirtualDefaultConfig()),
         isVirtual: true,
         reason: '未检测到 config.toml',
         detail: `配置文件不存在: ${CONFIG_FILE}`,
@@ -3108,6 +3261,45 @@ function applyReasoningEffortToTemplate(template, reasoningEffort) {
     return content;
 }
 
+function normalizePositiveIntegerParam(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    const text = typeof value === 'number'
+        ? String(value)
+        : (typeof value === 'string' ? value.trim() : String(value).trim());
+    if (!text) {
+        return null;
+    }
+    if (!/^\d+$/.test(text)) {
+        return null;
+    }
+    const parsed = Number.parseInt(text, 10);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        return null;
+    }
+    return parsed;
+}
+
+function applyPositiveIntegerConfigToTemplate(template, key, value) {
+    let content = typeof template === 'string' ? template : '';
+    const normalized = normalizePositiveIntegerParam(value);
+    if (!key || normalized === null) {
+        return content;
+    }
+
+    const hasBom = content.charCodeAt(0) === 0xFEFF;
+    const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
+    if (hasBom) {
+        content = content.slice(1);
+    }
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = new RegExp(`^\\s*${escapedKey}\\s*=\\s*[^\\n]*\\n?`, 'gmi');
+    content = content.replace(pattern, '');
+    content = content.replace(new RegExp(`^(?:[\\t ]*${lineEnding})+`), '');
+    return `${hasBom ? '\uFEFF' : ''}${key} = ${normalized}${lineEnding}${content}`;
+}
+
 function getConfigTemplate(params = {}) {
     let content = EMPTY_CONFIG_FALLBACK_TEMPLATE;
     if (fs.existsSync(CONFIG_FILE)) {
@@ -3118,8 +3310,22 @@ function getConfigTemplate(params = {}) {
             }
         } catch (e) {}
     }
-    const selectedProvider = params.provider || '';
-    const selectedModel = params.model || '';
+    if (
+        params.modelAutoCompactTokenLimit !== undefined
+        && params.modelAutoCompactTokenLimit !== null
+        && normalizePositiveIntegerParam(params.modelAutoCompactTokenLimit) === null
+    ) {
+        return { error: 'modelAutoCompactTokenLimit must be a positive integer' };
+    }
+    if (
+        params.modelContextWindow !== undefined
+        && params.modelContextWindow !== null
+        && normalizePositiveIntegerParam(params.modelContextWindow) === null
+    ) {
+        return { error: 'modelContextWindow must be a positive integer' };
+    }
+    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);
@@ -3127,11 +3333,54 @@ function getConfigTemplate(params = {}) {
     if (typeof params.reasoningEffort === 'string') {
         template = applyReasoningEffortToTemplate(template, params.reasoningEffort);
     }
+    if (!/^\s*model_auto_compact_token_limit\s*=.*$/m.test(template)) {
+        template = applyPositiveIntegerConfigToTemplate(
+            template,
+            'model_auto_compact_token_limit',
+            DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT
+        );
+    }
+    if (!/^\s*model_context_window\s*=.*$/m.test(template)) {
+        template = applyPositiveIntegerConfigToTemplate(
+            template,
+            'model_context_window',
+            DEFAULT_MODEL_CONTEXT_WINDOW
+        );
+    }
+    if (params.modelAutoCompactTokenLimit !== undefined) {
+        template = applyPositiveIntegerConfigToTemplate(
+            template,
+            'model_auto_compact_token_limit',
+            params.modelAutoCompactTokenLimit
+        );
+    }
+    if (params.modelContextWindow !== undefined) {
+        template = applyPositiveIntegerConfigToTemplate(
+            template,
+            'model_context_window',
+            params.modelContextWindow
+        );
+    }
     return {
         template
     };
 }
 
+function readPositiveIntegerConfigValue(config, key) {
+    const options = arguments[2] && typeof arguments[2] === 'object' ? arguments[2] : {};
+    const useDefaultsWhenMissing = options.useDefaultsWhenMissing !== false;
+    if (!config || typeof config !== 'object' || !key) {
+        return '';
+    }
+    const raw = config[key];
+    if (raw === undefined && useDefaultsWhenMissing) {
+        if (key === 'model_context_window') return DEFAULT_MODEL_CONTEXT_WINDOW;
+        if (key === 'model_auto_compact_token_limit') return DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT;
+    }
+    const normalized = normalizePositiveIntegerParam(raw);
+    return normalized === null ? '' : normalized;
+}
+
 function applyConfigTemplate(params = {}) {
     const template = typeof params.template === 'string' ? params.template : '';
     if (!template.trim()) {
@@ -3145,6 +3394,20 @@ function applyConfigTemplate(params = {}) {
         return { error: `模板 TOML 解析失败: ${e.message}` };
     }
 
+    if (
+        Object.prototype.hasOwnProperty.call(parsed, 'model_context_window')
+        && normalizePositiveIntegerParam(parsed.model_context_window) === null
+    ) {
+        return { error: '模板中的 model_context_window 必须是正整数' };
+    }
+
+    if (
+        Object.prototype.hasOwnProperty.call(parsed, 'model_auto_compact_token_limit')
+        && normalizePositiveIntegerParam(parsed.model_auto_compact_token_limit) === null
+    ) {
+        return { error: '模板中的 model_auto_compact_token_limit 必须是正整数' };
+    }
+
     if (!parsed.model_provider || typeof parsed.model_provider !== 'string') {
         return { error: '模板缺少 model_provider' };
     }
@@ -3196,7 +3459,7 @@ function addProviderToConfig(params = {}) {
         return { error: 'local provider 为系统保留名称，不可新增' };
     }
     if (isBuiltinProxyProvider(name) && !allowManaged) {
-        return { error: '本地代理配置为系统内建项，不可手动添加' };
+        return { error: 'codexmate-proxy 为保留名称，不可手动添加' };
     }
 
     ensureConfigDir();
@@ -3274,7 +3537,7 @@ function updateProviderInConfig(params = {}) {
         if (isDefaultLocalProvider(name)) {
             return { error: 'local provider 为系统保留项，不可编辑' };
         }
-        return { error: '本地代理配置为系统内建项，不可编辑' };
+        return { error: 'codexmate-proxy 为保留名称，不可编辑' };
     }
 
     try {
@@ -3292,7 +3555,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 不存在' };
@@ -3322,7 +3585,7 @@ function performProviderDeletion(name, options = {}) {
     if (isNonDeletableProvider(name)) {
         const msg = isDefaultLocalProvider(name)
             ? 'local provider 为系统保留项，不可删除'
-            : '本地代理配置为系统内建项，不可删除';
+            : 'codexmate-proxy 为保留名称，不可删除';
         if (!silent) console.error('错误:', msg);
         return { error: msg };
     }
@@ -3611,7 +3874,7 @@ function normalizePathForCompare(targetPath, options = {}) {
     return ignoreCase ? resolved.toLowerCase() : resolved;
 }
 
-function isPathInside(targetPath, rootPath) {
+function isPathInside(targetPath, rootPath) {
     if (!targetPath || !rootPath) {
         return false;
     }
@@ -3621,9 +3884,33 @@ function isPathInside(targetPath, rootPath) {
     if (resolvedTarget === resolvedRoot) {
         return true;
     }
-    const rootWithSlash = resolvedRoot.endsWith(path.sep) ? resolvedRoot : resolvedRoot + path.sep;
-    return resolvedTarget.startsWith(rootWithSlash);
-}
+    const separator = resolvedRoot.includes('/') && !resolvedRoot.includes('\\') ? '/' : path.sep;
+    const rootWithSlash = resolvedRoot.endsWith(separator) ? resolvedRoot : resolvedRoot + separator;
+    return resolvedTarget.startsWith(rootWithSlash);
+}
+
+function resolveCopyTargetRoot(targetDir) {
+    const base = typeof targetDir === 'string' ? targetDir.trim() : '';
+    const pathApi = base.includes('/') && !base.includes('\\') && path.posix ? path.posix : path;
+    const suffixSegments = [];
+    let current = pathApi.resolve(base || '');
+    while (current && !fs.existsSync(current)) {
+        const parent = pathApi.dirname(current);
+        if (!parent || parent === current) {
+            break;
+        }
+        suffixSegments.unshift(pathApi.basename(current));
+        current = parent;
+    }
+    let resolvedRoot = normalizePathForCompare(current || base);
+    if (!resolvedRoot) {
+        resolvedRoot = pathApi.resolve(base || '');
+    }
+    for (const segment of suffixSegments) {
+        resolvedRoot = pathApi.join(resolvedRoot, segment);
+    }
+    return resolvedRoot;
+}
 
 function collectJsonlFiles(rootDir, maxFiles = 5000) {
     if (!fs.existsSync(rootDir)) {
@@ -4408,25 +4695,7 @@ function extractMessageFromRecord(record, source) {
     return { role, text };
 }
 
-function scanSessionContentForQuery(session, tokens, options = {}) {
-    if (!session || !Array.isArray(tokens) || tokens.length === 0) {
-        return { hit: false, count: 0, snippets: [] };
-    }
-
-    const filePath = resolveSessionFilePath(session.source, session.filePath, session.sessionId);
-    if (!filePath) {
-        return { hit: false, count: 0, snippets: [] };
-    }
-
-    const maxBytes = Number.isFinite(Number(options.maxBytes))
-        ? Math.max(1024, Number(options.maxBytes))
-        : SESSION_CONTENT_READ_BYTES;
-    const headText = getFileHeadText(filePath, maxBytes);
-    if (!headText) {
-        return { hit: false, count: 0, snippets: [] };
-    }
-
-    const records = parseJsonlContent(headText);
+function createSessionQueryScanState(tokens, options = {}) {
     const mode = normalizeQueryMode(options.mode);
     const roleFilter = normalizeRoleFilter(options.roleFilter);
     const maxMatches = Number.isFinite(Number(options.maxMatches))
@@ -4436,43 +4705,137 @@ function scanSessionContentForQuery(session, tokens, options = {}) {
         ? Math.max(0, Number(options.snippetLimit))
         : 0;
 
-    const messages = [];
+    return {
+        tokens,
+        mode,
+        roleFilter,
+        maxMatches,
+        snippetLimit,
+        count: 0,
+        snippets: [],
+        leadingSystem: roleFilter !== 'system'
+    };
+}
+
+function consumeSessionQueryMessage(state, message) {
+    if (!state || typeof state !== 'object' || !message) {
+        return false;
+    }
+
+    const role = normalizeRole(message.role);
+    const text = typeof message.text === 'string' ? message.text : '';
+    if (!role || !text) {
+        return false;
+    }
+
+    if (state.leadingSystem && (role === 'system' || isBootstrapLikeText(text))) {
+        return false;
+    }
+    state.leadingSystem = false;
+
+    if (state.roleFilter !== 'all' && role !== state.roleFilter) {
+        return false;
+    }
+    if (!matchTokensInText(text, state.tokens, state.mode)) {
+        return false;
+    }
+
+    state.count += 1;
+    if (state.snippetLimit > 0 && state.snippets.length < state.snippetLimit) {
+        state.snippets.push(truncateText(text));
+    }
+    return state.count >= state.maxMatches;
+}
+
+function buildSessionQueryScanResult(state) {
+    return {
+        hit: !!(state && state.count > 0),
+        count: state && Number.isFinite(state.count) ? state.count : 0,
+        snippets: state && Array.isArray(state.snippets) ? state.snippets : []
+    };
+}
+
+function scanSessionContentForQueryInRecords(records, source, state) {
+    if (!Array.isArray(records) || !state) {
+        return buildSessionQueryScanResult(state);
+    }
+
     for (const record of records) {
-        const message = extractMessageFromRecord(record, session.source);
-        if (!message || !message.text) {
+        const message = extractMessageFromRecord(record, source);
+        if (!message) {
             continue;
         }
-        messages.push(message);
+        if (consumeSessionQueryMessage(state, message)) {
+            break;
+        }
     }
 
-    const filteredMessages = roleFilter === 'system'
-        ? messages
-        : removeLeadingSystemMessage(messages);
+    return buildSessionQueryScanResult(state);
+}
 
-    let count = 0;
-    const snippets = [];
+async function scanSessionContentForQuery(session, tokens, options = {}) {
+    if (!session || !Array.isArray(tokens) || tokens.length === 0) {
+        return { hit: false, count: 0, snippets: [] };
+    }
 
-    for (const message of filteredMessages) {
-        if (roleFilter !== 'all' && message.role !== roleFilter) {
-            continue;
-        }
-        if (!matchTokensInText(message.text, tokens, mode)) {
-            continue;
+    const filePath = resolveSessionFilePath(session.source, session.filePath, session.sessionId);
+    if (!filePath) {
+        return { hit: false, count: 0, snippets: [] };
+    }
+
+    const rawMaxBytes = Number(options.maxBytes);
+    const maxBytes = Number.isFinite(rawMaxBytes) && rawMaxBytes > 0
+        ? Math.max(1024, rawMaxBytes)
+        : 0;
+    const state = createSessionQueryScanState(tokens, options);
+    let stream;
+    let rl;
+    try {
+        stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+        rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+
+        let bytesRead = 0;
+        for await (const line of rl) {
+            if (maxBytes > 0 && bytesRead >= maxBytes) {
+                break;
+            }
+
+            bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            } catch (e) {
+                continue;
+            }
+
+            const message = extractMessageFromRecord(record, session.source);
+            if (!message) {
+                continue;
+            }
+            if (consumeSessionQueryMessage(state, message)) {
+                break;
+            }
         }
 
-        count += 1;
-        if (snippetLimit > 0 && snippets.length < snippetLimit) {
-            snippets.push(truncateText(message.text));
+        return buildSessionQueryScanResult(state);
+    } catch (e) {
+        return scanSessionContentForQueryInRecords(readJsonlRecords(filePath), session.source, state);
+    } finally {
+        if (rl) {
+            try { rl.close(); } catch (e) {}
         }
-        if (count >= maxMatches) {
-            break;
+        if (stream && !stream.destroyed && stream.destroy) {
+            try { stream.destroy(); } catch (e) {}
         }
     }
-
-    return { hit: count > 0, count, snippets };
 }
 
-function applySessionQueryFilter(sessions, options = {}) {
+async function applySessionQueryFilter(sessions, options = {}) {
     const tokens = Array.isArray(options.tokens) ? options.tokens : [];
     if (tokens.length === 0) {
         return sessions;
@@ -4486,7 +4849,7 @@ function applySessionQueryFilter(sessions, options = {}) {
         : DEFAULT_CONTENT_SCAN_LIMIT;
     const contentScanBytes = Number.isFinite(Number(options.contentScanBytes))
         ? Math.max(1024, Number(options.contentScanBytes))
-        : SESSION_CONTENT_READ_BYTES;
+        : 0;
 
     let scanned = 0;
     const results = [];
@@ -4504,7 +4867,7 @@ function applySessionQueryFilter(sessions, options = {}) {
         const shouldScanContent = scope === 'content' || scope === 'all' || !summaryHit;
         if (shouldScanContent && scanned < contentScanLimit) {
             scanned += 1;
-            contentInfo = scanSessionContentForQuery(session, tokens, {
+            contentInfo = await scanSessionContentForQuery(session, tokens, {
                 mode,
                 roleFilter,
                 maxBytes: contentScanBytes,
@@ -4979,7 +5342,7 @@ function listClaudeSessions(limit, options = {}) {
     return mergeAndLimitSessions(sessions, limit);
 }
 
-function listAllSessions(params = {}) {
+async function listAllSessions(params = {}) {
     const source = params.source === 'codex' || params.source === 'claude'
         ? params.source
         : 'all';
@@ -5021,7 +5384,7 @@ function listAllSessions(params = {}) {
 
     let result = sessions;
     if (hasQuery) {
-        result = applySessionQueryFilter(result, {
+        result = await applySessionQueryFilter(result, {
             tokens: queryTokens,
             queryMode: params.queryMode,
             queryScope: params.queryScope,
@@ -5057,7 +5420,7 @@ async function listAllSessionsData(params = {}) {
         }
     }
 
-    const sessions = listAllSessions(params);
+    const sessions = await listAllSessions(params);
     const hydratedSessions = await hydrateSessionItemsExactMessageCount(sessions);
     const result = hydratedSessions.map((item) => {
         if (!item || typeof item !== 'object' || Array.isArray(item)) {
@@ -5306,6 +5669,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) {
@@ -5582,131 +6063,11 @@ 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;
-    }
-
-    const switchToProxy = params.switchToProxy !== false;
-    let targetModel = '';
-    if (switchToProxy) {
-        try {
-            targetModel = cmdSwitch(BUILTIN_PROXY_PROVIDER_NAME, true) || '';
-        } catch (e) {
-            return { error: `写入代理 provider 成功，但切换失败: ${e.message}` };
-        }
-    }
-
-    return {
-        success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl,
-        switched: switchToProxy,
-        model: targetModel
-    };
+    return { error: '该功能已移除' };
 }
 
-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 };
-    }
-    let nextSettings = saveResult.settings;
-
-    let upstreamResult = resolveBuiltinProxyUpstream(nextSettings);
-    if (upstreamResult.error) {
-        return { error: upstreamResult.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
-    );
-
-    if (shouldRestart) {
-        await stopBuiltinProxyRuntime();
-    }
-
-    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);
-                }
-            }
-        }
-        if (!startRes.success) {
-            return { error: startRes.error || '启动内建代理失败' };
-        }
-    }
-
-    let applyRes = {
-        success: true,
-        provider: BUILTIN_PROXY_PROVIDER_NAME,
-        baseUrl: buildProxyListenUrl(nextSettings),
-        switched: false,
-        model: ''
-    };
-    if (switchToProxy) {
-        applyRes = applyBuiltinProxyProvider({ switchToProxy: true });
-        if (applyRes.error) {
-            return applyRes;
-        }
-    }
-
-    const status = getBuiltinProxyStatus();
-    return {
-        success: true,
-        provider: applyRes.provider,
-        baseUrl: applyRes.baseUrl,
-        switched: applyRes.switched,
-        model: applyRes.model || '',
-        settings: status.settings,
-        runtime: status.runtime
-    };
+async function ensureBuiltinProxyForCodexDefault(params = {}) {
+    return { error: '该功能已移除' };
 }
 
 function removeClaudeSessionIndexEntry(indexPath, sessionFilePath, sessionId) {
@@ -7236,63 +7597,210 @@ function resolveSpeedTestTarget(params) {
         if (!provider.base_url) {
             return { error: 'Provider missing URL' };
         }
+        const currentModel = typeof config.model === 'string' ? config.model.trim() : '';
+        const probeSpec = buildModelProbeSpec(provider, currentModel, provider.base_url);
+        if (probeSpec && probeSpec.url) {
+            return {
+                method: 'POST',
+                url: probeSpec.url,
+                body: probeSpec.body,
+                apiKey: provider.preferred_auth_method || ''
+            };
+        }
         return {
+            method: 'GET',
             url: provider.base_url,
             apiKey: provider.preferred_auth_method || ''
         };
     }
 
     if (params.url) {
-        return { url: params.url, apiKey: '' };
+        return {
+            method: 'GET',
+            url: params.url,
+            apiKey: typeof params.apiKey === 'string' ? params.apiKey : ''
+        };
     }
 
     return { error: 'Missing name or url' };
 }
 
-function runSpeedTest(targetUrl, apiKey, options = {}) {
-    return new Promise((resolve) => {
-        let parsed;
-        try {
-            parsed = new URL(targetUrl);
-        } catch (e) {
-            return resolve({ ok: false, error: 'Invalid URL' });
-        }
+function extractApiPayloadErrorMessage(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+    if (typeof payload.error === 'string' && payload.error.trim()) {
+        return payload.error.trim();
+    }
+    if (!payload.error || typeof payload.error !== 'object') {
+        return '';
+    }
+    if (typeof payload.error.message === 'string' && payload.error.message.trim()) {
+        return payload.error.message.trim();
+    }
+    if (typeof payload.error.code === 'string' && payload.error.code.trim()) {
+        return payload.error.code.trim();
+    }
+    return '';
+}
 
-        const timeoutMs = Number.isFinite(options.timeoutMs)
-            ? Math.max(1000, Number(options.timeoutMs))
-            : SPEED_TEST_TIMEOUT_MS;
+function resolveProviderChatTarget(params) {
+    const providerName = typeof (params && params.name) === 'string' ? params.name.trim() : '';
+    const prompt = typeof (params && params.prompt) === 'string' ? params.prompt.trim() : '';
+    if (!providerName) {
+        return { error: 'Provider name is required' };
+    }
+    if (!prompt) {
+        return { error: 'Prompt is required' };
+    }
 
-        const transport = parsed.protocol === 'https:' ? https : http;
-        const headers = {
-            'User-Agent': 'codexmate-speed-test',
-            'Accept': 'application/json'
-        };
-        if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-        }
+    const { config } = readConfigOrVirtualDefault();
+    const providers = config.model_providers || {};
+    const provider = providers[providerName];
+    if (!provider || typeof provider !== 'object') {
+        return { error: `Provider not found: ${providerName}` };
+    }
 
-        const start = Date.now();
-        const req = transport.request(parsed, { method: 'GET', headers }, (res) => {
-            res.on('data', () => {});
-            res.on('end', () => {
-                resolve({
-                    ok: true,
-                    status: res.statusCode || 0,
-                    durationMs: Date.now() - start
-                });
-            });
-        });
+    const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+    if (!baseUrl) {
+        return { error: `Provider ${providerName} missing URL` };
+    }
 
-        req.setTimeout(timeoutMs, () => {
-            req.destroy(new Error('timeout'));
-        });
+    const currentModels = readCurrentModels();
+    const savedModel = currentModels && typeof currentModels[providerName] === 'string'
+        ? currentModels[providerName].trim()
+        : '';
+    const activeProvider = typeof config.model_provider === 'string' ? config.model_provider.trim() : '';
+    const activeModel = typeof config.model === 'string' ? config.model.trim() : '';
+    const model = savedModel || (activeProvider === providerName ? activeModel : '');
+    if (!model) {
+        return { error: `Provider ${providerName} missing current model` };
+    }
+
+    const specs = buildModelConversationSpecs(provider, model, baseUrl, prompt, {
+        maxOutputTokens: 256
+    });
+    if (!specs.length) {
+        return { error: `Provider ${providerName} missing available conversation endpoint` };
+    }
+
+    return {
+        providerName,
+        provider,
+        model,
+        prompt,
+        specs,
+        apiKey: typeof provider.preferred_auth_method === 'string'
+            ? provider.preferred_auth_method.trim()
+            : ''
+    };
+}
+
+async function runProviderChatCheck(params = {}) {
+    const target = resolveProviderChatTarget(params);
+    if (target.error) {
+        return { ok: false, error: target.error };
+    }
 
-        req.on('error', (err) => {
-            resolve({ ok: false, error: err.message, durationMs: Date.now() - start });
+    const timeoutMs = Number.isFinite(params.timeoutMs)
+        ? Math.max(1000, Number(params.timeoutMs))
+        : 30000;
+    let finalSpec = target.specs[0];
+    let result = null;
+
+    for (let index = 0; index < target.specs.length; index += 1) {
+        const candidate = target.specs[index];
+        const probeResult = await probeJsonPost(candidate.url, candidate.body, {
+            apiKey: target.apiKey,
+            timeoutMs,
+            maxBytes: 512 * 1024
         });
+        finalSpec = candidate;
+        result = probeResult;
+        const shouldTryNextCandidate = index < target.specs.length - 1
+            && (!probeResult.ok || probeResult.status === 404);
+        if (!shouldTryNextCandidate) {
+            break;
+        }
+    }
 
-        req.end();
-    });
+    if (!result || !result.ok) {
+        return {
+            ok: false,
+            provider: target.providerName,
+            model: target.model,
+            url: finalSpec.url,
+            status: Number.isFinite(result && result.status) ? result.status : 0,
+            durationMs: Number.isFinite(result && result.durationMs) ? result.durationMs : 0,
+            reply: '',
+            rawPreview: '',
+            error: result && result.error ? result.error : 'request failed'
+        };
+    }
+
+    let payload = null;
+    try {
+        payload = result.body ? JSON.parse(result.body) : null;
+    } catch (e) {
+        payload = null;
+    }
+
+    const payloadError = extractApiPayloadErrorMessage(payload);
+    if (result.status >= 400 || payloadError) {
+        return {
+            ok: false,
+            provider: target.providerName,
+            model: target.model,
+            url: finalSpec.url,
+            status: Number.isFinite(result.status) ? result.status : 0,
+            durationMs: Number.isFinite(result.durationMs) ? result.durationMs : 0,
+            reply: '',
+            rawPreview: result.body ? truncateText(result.body, 600) : '',
+            error: payloadError || `HTTP ${result.status}`
+        };
+    }
+
+    const reply = extractModelResponseText(payload);
+    return {
+        ok: true,
+        provider: target.providerName,
+        model: target.model,
+        url: finalSpec.url,
+        status: Number.isFinite(result.status) ? result.status : 0,
+        durationMs: Number.isFinite(result.durationMs) ? result.durationMs : 0,
+        reply,
+        rawPreview: reply ? '' : (result.body ? truncateText(result.body, 600) : ''),
+        error: ''
+    };
+}
+
+function runSpeedTest(targetUrl, apiKey, options = {}) {
+    const timeoutMs = Number.isFinite(options.timeoutMs)
+        ? Math.max(1000, Number(options.timeoutMs))
+        : SPEED_TEST_TIMEOUT_MS;
+    const method = typeof options.method === 'string' ? options.method.toUpperCase() : 'GET';
+    if (method === 'POST') {
+        return probeJsonPost(targetUrl, options.body || {}, {
+            apiKey,
+            timeoutMs,
+            maxBytes: 256 * 1024
+        }).then((result) => ({
+            ok: !!result.ok,
+            status: Number.isFinite(result.status) ? result.status : 0,
+            durationMs: Number.isFinite(result.durationMs) ? result.durationMs : 0,
+            error: result.ok ? '' : (result.error || '')
+        }));
+    }
+    return probeUrl(targetUrl, {
+        apiKey,
+        timeoutMs,
+        maxBytes: 256 * 1024
+    }).then((result) => ({
+        ok: !!result.ok,
+        status: Number.isFinite(result.status) ? result.status : 0,
+        durationMs: Number.isFinite(result.durationMs) ? result.durationMs : 0,
+        error: result.ok ? '' : (result.error || '')
+    }));
 }
 
 // ============================================================================
@@ -7348,7 +7856,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;
@@ -7634,7 +8143,7 @@ async function cmdModels() {
 
 // 切换提供商
 function cmdSwitch(providerName, silent = false) {
-    const config = readConfig();
+    const config = sanitizeRemovedBuiltinProxyProvider(readConfig());
     const providers = config.model_providers || {};
 
     if (!providers[providerName]) {
@@ -7737,6 +8246,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]) {
@@ -7801,7 +8314,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);
     }
@@ -9504,10 +10017,19 @@ function formatHostForUrl(host) {
     return value;
 }
 
-function watchPathsForRestart(targets, onChange) {
-    const disposers = [];
-    const debounceMs = 300;
-    let timer = null;
+// #region watchPathsForRestart
+function watchPathsForRestart(targets, onChange) {
+    const debounceMs = 300;
+    let timer = null;
+    const watcherEntries = new Map();
+    const getPathApi = (targetPath) => {
+        const value = typeof targetPath === 'string' ? targetPath.trim() : '';
+        return value.includes('/') && !value.includes('\\') && path.posix ? path.posix : path;
+    };
+    const getPathSeparator = (targetPath) => {
+        const pathApi = getPathApi(targetPath);
+        return pathApi.sep || (pathApi === path.posix ? '/' : path.sep);
+    };
 
     const trigger = (info) => {
         if (timer) clearTimeout(timer);
@@ -9517,35 +10039,205 @@ function watchPathsForRestart(targets, onChange) {
         }, debounceMs);
     };
 
-    const addWatcher = (target, recursive) => {
-        if (!fs.existsSync(target)) return;
+    const closeWatcher = (watchKey) => {
+        const entry = watcherEntries.get(watchKey);
+        if (!entry) return;
+        watcherEntries.delete(watchKey);
         try {
-            const watcher = fs.watch(target, { recursive }, (eventType, filename) => {
+            entry.watcher.close();
+        } catch (_) {}
+    };
+
+    const listDirectoryTree = (rootDir) => {
+        const queue = [rootDir];
+        const directories = [];
+        const seen = new Set();
+        const pathApi = getPathApi(rootDir);
+        while (queue.length) {
+            const current = queue.shift();
+            if (!current || seen.has(current) || !fs.existsSync(current)) {
+                continue;
+            }
+            seen.add(current);
+            let stat = null;
+            try {
+                stat = fs.statSync(current);
+            } catch (_) {
+                continue;
+            }
+            if (!stat || !stat.isDirectory()) {
+                continue;
+            }
+            directories.push(current);
+            let entries = [];
+            try {
+                entries = fs.readdirSync(current, { withFileTypes: true });
+            } catch (_) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry && typeof entry.isDirectory === 'function' && entry.isDirectory()) {
+                    queue.push(pathApi.join(current, entry.name));
+                }
+            }
+        }
+        return directories;
+    };
+
+    const isSameOrNestedPath = (candidate, rootDir) => {
+        const separator = getPathSeparator(rootDir);
+        return candidate === rootDir || candidate.startsWith(`${rootDir}${separator}`);
+    };
+
+    const addWatcher = (target, recursive, isDirectory = false) => {
+        if (!fs.existsSync(target)) return;
+        const watchKey = `${recursive ? 'recursive' : 'plain'}:${target}`;
+        if (watcherEntries.has(watchKey)) {
+            return true;
+        }
+        try {
+            const pathApi = getPathApi(target);
+            const basename = isDirectory ? '' : pathApi.basename(target);
+            const watchTarget = isDirectory ? target : pathApi.dirname(target);
+            const watcher = fs.watch(watchTarget, { recursive }, (eventType, filename) => {
+                if (isDirectory && !recursive && eventType === 'rename') {
+                    syncDirectoryTree(target);
+                }
                 if (!filename) return;
-                const lower = filename.toLowerCase();
-                if (!(/\.(html|js|mjs|css)$/.test(lower))) return;
-                trigger({ target, eventType, filename });
+                let normalizedFilename = String(filename).replace(/\\/g, '/');
+                if (!isDirectory) {
+                    const fileNameOnly = normalizedFilename.split('/').pop();
+                    if (fileNameOnly !== basename) {
+                        return;
+                    }
+                    normalizedFilename = basename;
+                }
+                const lower = normalizedFilename.toLowerCase();
+                if (!(/\.(html|js|mjs|cjs|css)$/.test(lower))) return;
+                trigger({ target, eventType, filename: normalizedFilename });
+            });
+            watcher.on('error', () => {
+                closeWatcher(watchKey);
+                if (isDirectory && recursive && !fs.existsSync(target)) {
+                    syncDirectoryTree(target);
+                    addMissingDirectoryWatcher(target);
+                    return;
+                }
+                if (isDirectory && !recursive) {
+                    syncDirectoryTree(target);
+                } else if (fs.existsSync(target)) {
+                    addWatcher(target, recursive, isDirectory);
+                }
+            });
+            watcherEntries.set(watchKey, {
+                watcher,
+                target,
+                recursive,
+                isDirectory
             });
-            disposers.push(() => watcher.close());
             return true;
         } catch (e) {
             return false;
         }
     };
 
+    const addMissingDirectoryWatcher = (target) => {
+        const pathApi = getPathApi(target);
+        const parentDir = pathApi.dirname(target);
+        if (!parentDir || parentDir === target || !fs.existsSync(parentDir)) {
+            return false;
+        }
+        const watchKey = `missing-dir:${target}`;
+        if (watcherEntries.has(watchKey)) {
+            return true;
+        }
+        const basename = path.basename(target);
+        try {
+            const watcher = fs.watch(parentDir, { recursive: false }, (_eventType, filename) => {
+                if (!filename) return;
+                const fileNameOnly = String(filename).replace(/\\/g, '/').split('/').pop();
+                if (fileNameOnly !== basename) {
+                    return;
+                }
+                if (!fs.existsSync(target)) {
+                    syncDirectoryTree(target);
+                    return;
+                }
+                closeWatcher(watchKey);
+                const ok = addWatcher(target, true, true);
+                if (!ok) {
+                    syncDirectoryTree(target);
+                }
+            });
+            watcher.on('error', () => {
+                closeWatcher(watchKey);
+                if (fs.existsSync(parentDir) && !fs.existsSync(target)) {
+                    addMissingDirectoryWatcher(target);
+                }
+            });
+            watcherEntries.set(watchKey, {
+                watcher,
+                target: parentDir,
+                recursive: false,
+                isDirectory: false
+            });
+            return true;
+        } catch (_) {
+            return false;
+        }
+    };
+
+    const syncDirectoryTree = (rootDir) => {
+        const directories = listDirectoryTree(rootDir);
+        const existingDirectorySet = new Set(directories);
+        for (const [watchKey, entry] of Array.from(watcherEntries.entries())) {
+            if (!entry.isDirectory || entry.recursive) {
+                continue;
+            }
+            if (!isSameOrNestedPath(entry.target, rootDir)) {
+                continue;
+            }
+            if (!existingDirectorySet.has(entry.target)) {
+                closeWatcher(watchKey);
+            }
+        }
+        for (const directory of directories) {
+            addWatcher(directory, false, true);
+        }
+    };
+
     for (const target of targets) {
-        const ok = addWatcher(target, true);
+        if (!fs.existsSync(target)) continue;
+        let stat = null;
+        try {
+            stat = fs.statSync(target);
+        } catch (_) {
+            continue;
+        }
+        if (stat && stat.isDirectory()) {
+            const ok = addWatcher(target, true, true);
+            if (!ok) {
+                syncDirectoryTree(target);
+            }
+            continue;
+        }
+        const ok = addWatcher(target, true, false);
         if (!ok) {
-            addWatcher(target, false);
+            addWatcher(target, false, false);
         }
     }
 
     return () => {
-        for (const dispose of disposers) {
-            try { dispose(); } catch (_) {}
+        if (timer) {
+            clearTimeout(timer);
+            timer = null;
+        }
+        for (const watchKey of Array.from(watcherEntries.keys())) {
+            closeWatcher(watchKey);
         }
     };
 }
+// #endregion watchPathsForRestart
 
 function writeJsonResponse(res, statusCode, payload) {
     const body = JSON.stringify(payload, null, 2);
@@ -9633,22 +10325,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) {
@@ -9657,13 +10382,55 @@ async function handleImportCodexSkillsZipUpload(req, res) {
     }
 }
 
+const PUBLIC_WEB_UI_DYNAMIC_ASSETS = new Map([
+    ['app.js', {
+        mime: 'application/javascript; charset=utf-8',
+        reader: readExecutableBundledWebUiScript
+    }],
+    ['index.html', {
+        mime: 'text/html; charset=utf-8',
+        reader: readBundledWebUiHtml
+    }],
+    ['logic.mjs', {
+        mime: 'application/javascript; charset=utf-8',
+        reader: readExecutableBundledJavaScriptModule
+    }],
+    ['styles.css', {
+        mime: 'text/css; charset=utf-8',
+        reader: readBundledWebUiCss
+    }]
+]);
+
+const PUBLIC_WEB_UI_STATIC_ASSETS = new Set([
+    'modules/config-mode.computed.mjs',
+    'modules/skills.computed.mjs',
+    'modules/skills.methods.mjs',
+    'session-helpers.mjs'
+]);
+
 function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser }) {
     const connections = new Set();
+    const writeWebUiAssetError = (res, requestPath, error) => {
+        const message = error && error.message ? error.message : String(error);
+        console.error(`! Web UI 资源读取失败 [${requestPath}]:`, message);
+        if (res.headersSent) {
+            try {
+                res.destroy(error);
+            } catch (_) {}
+            return;
+        }
+        res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Internal Server Error');
+    };
 
     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') {
@@ -9690,22 +10457,38 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                     let result;
 
                     switch (action) {
-                        case 'status':
+                        case 'status': {
                             const statusConfigResult = readConfigOrVirtualDefault();
                             const config = statusConfigResult.config;
                             const serviceTier = typeof config.service_tier === 'string' ? config.service_tier.trim() : '';
                             const modelReasoningEffort = typeof config.model_reasoning_effort === 'string' ? config.model_reasoning_effort.trim() : '';
+                            const budgetReadOptions = {
+                                useDefaultsWhenMissing: !hasConfigLoadError(statusConfigResult)
+                            };
+                            const modelContextWindow = readPositiveIntegerConfigValue(
+                                config,
+                                'model_context_window',
+                                budgetReadOptions
+                            );
+                            const modelAutoCompactTokenLimit = readPositiveIntegerConfigValue(
+                                config,
+                                'model_auto_compact_token_limit',
+                                budgetReadOptions
+                            );
                             result = {
                                 provider: config.model_provider || '未设置',
                                 model: config.model || '未设置',
                                 serviceTier,
                                 modelReasoningEffort,
+                                modelContextWindow,
+                                modelAutoCompactTokenLimit,
                                 configReady: !statusConfigResult.isVirtual,
                                 configErrorType: statusConfigResult.errorType || '',
                                 configNotice: statusConfigResult.reason || '',
                                 initNotice: consumeInitNotice()
                             };
                             break;
+                        }
                         case 'install-status':
                             result = buildInstallStatusReport();
                             break;
@@ -9795,6 +10578,21 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         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;
@@ -9872,7 +10670,11 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                                 result = { error: target.error };
                                 break;
                             }
-                            result = await runSpeedTest(target.url, target.apiKey);
+                            result = await runSpeedTest(target.url, target.apiKey, target);
+                            break;
+                        }
+                        case 'provider-chat-check': {
+                            result = await runProviderChatCheck(params || {});
                             break;
                         }
                         case 'list-sessions':
@@ -10053,6 +10855,14 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                     res.end(errorBody, 'utf-8');
                 }
             });
+        } else if (requestPath === '/web-ui') {
+            try {
+                const html = readBundledWebUiHtml(htmlPath);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+            } catch (error) {
+                writeWebUiAssetError(res, requestPath, error);
+            }
         } else if (requestPath.startsWith('/web-ui/')) {
             const normalized = path.normalize(requestPath).replace(/^([\\.\\/])+/, '');
             const filePath = path.join(__dirname, normalized);
@@ -10061,6 +10871,23 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                 res.end('Forbidden');
                 return;
             }
+            const relativePath = path.relative(webDir, filePath).replace(/\\/g, '/');
+            const dynamicAsset = PUBLIC_WEB_UI_DYNAMIC_ASSETS.get(relativePath);
+            if (dynamicAsset) {
+                try {
+                    const assetBody = dynamicAsset.reader(filePath);
+                    res.writeHead(200, { 'Content-Type': dynamicAsset.mime });
+                    res.end(assetBody, 'utf-8');
+                } catch (error) {
+                    writeWebUiAssetError(res, requestPath, error);
+                }
+                return;
+            }
+            if (!PUBLIC_WEB_UI_STATIC_ASSETS.has(relativePath)) {
+                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Not Found');
+                return;
+            }
             if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
                 res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
                 res.end('Not Found');
@@ -10133,9 +10960,13 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
             res.writeHead(200, { 'Content-Type': mime });
             fs.createReadStream(filePath).pipe(res);
         } else {
-            const html = fs.readFileSync(htmlPath, 'utf-8');
-            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end(html);
+            try {
+                const html = readBundledWebUiHtml(htmlPath);
+                res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+                res.end(html);
+            } catch (error) {
+                writeWebUiAssetError(res, requestPath, error);
+            }
         }
     });
 
@@ -10154,7 +10985,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);
@@ -10287,6 +11120,7 @@ function cmdStart(options = {}) {
 
     const port = resolveWebPort();
     const host = resolveWebHost(options);
+    releaseRunPortIfNeeded(port, host);
 
     let serverHandle = createWebServer({
         htmlPath,
@@ -10297,25 +11131,6 @@ 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 requestWebUiRestart = createSerializedWebUiRestartHandler(async (info) => {
             const fileLabel = info && info.filename ? info.filename : (info && info.target ? path.basename(info.target) : 'unknown');
             console.log(`\n~ 侦测到前端变更 (${fileLabel})，重启中...`);
@@ -10507,111 +11322,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) {
@@ -11283,11 +11995,26 @@ function buildMcpStatusPayload() {
     const config = statusConfigResult.config;
     const serviceTier = typeof config.service_tier === 'string' ? config.service_tier.trim() : '';
     const modelReasoningEffort = typeof config.model_reasoning_effort === 'string' ? config.model_reasoning_effort.trim() : '';
+    const budgetReadOptions = {
+        useDefaultsWhenMissing: !hasConfigLoadError(statusConfigResult)
+    };
+    const modelContextWindow = readPositiveIntegerConfigValue(
+        config,
+        'model_context_window',
+        budgetReadOptions
+    );
+    const modelAutoCompactTokenLimit = readPositiveIntegerConfigValue(
+        config,
+        'model_auto_compact_token_limit',
+        budgetReadOptions
+    );
     return {
         provider: config.model_provider || '未设置',
         model: config.model || '未设置',
         serviceTier,
         modelReasoningEffort,
+        modelContextWindow,
+        modelAutoCompactTokenLimit,
         configReady: !statusConfigResult.isVirtual,
         configErrorType: statusConfigResult.errorType || '',
         configNotice: statusConfigResult.reason || '',
@@ -11385,6 +12112,8 @@ const BUILTIN_WORKFLOW_DEFINITIONS = Object.freeze({
                 model: { type: 'string' },
                 serviceTier: { type: 'string' },
                 reasoningEffort: { type: 'string' },
+                modelContextWindow: { type: ['string', 'number'] },
+                modelAutoCompactTokenLimit: { type: ['string', 'number'] },
                 apply: { type: 'boolean' }
             },
             required: ['provider'],
@@ -11399,7 +12128,9 @@ const BUILTIN_WORKFLOW_DEFINITIONS = Object.freeze({
                     provider: '{{input.provider}}',
                     model: '{{input.model}}',
                     serviceTier: '{{input.serviceTier}}',
-                    reasoningEffort: '{{input.reasoningEffort}}'
+                    reasoningEffort: '{{input.reasoningEffort}}',
+                    modelContextWindow: '{{input.modelContextWindow}}',
+                    modelAutoCompactTokenLimit: '{{input.modelAutoCompactTokenLimit}}'
                 }
             },
             {
@@ -11968,7 +12699,7 @@ function createMcpTools(options = {}) {
 
     pushTool({
         name: 'codexmate.config.template.get',
-        description: 'Get Codex config template with optional provider/model/service tier/reasoning effort.',
+        description: 'Get Codex config template with optional provider/model/service tier/reasoning effort/context budget.',
         readOnly: true,
         inputSchema: {
             type: 'object',
@@ -11976,7 +12707,9 @@ function createMcpTools(options = {}) {
                 provider: { type: 'string' },
                 model: { type: 'string' },
                 serviceTier: { type: 'string' },
-                reasoningEffort: { type: 'string' }
+                reasoningEffort: { type: 'string' },
+                modelContextWindow: { type: ['string', 'number'] },
+                modelAutoCompactTokenLimit: { type: ['string', 'number'] }
             },
             additionalProperties: false
         },
@@ -12685,11 +13418,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]');