codexmate 0.0.19 → 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,6 +65,13 @@ 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 = '0.0.0.0';
@@ -93,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;
@@ -172,37 +183,47 @@ const CLI_INSTALL_TARGETS = Object.freeze([
 const HTTP_KEEP_ALIVE_AGENT = new http.Agent({ keepAlive: true });
 const HTTPS_KEEP_ALIVE_AGENT = new https.Agent({ keepAlive: true });
 
-function getCodexSkillsDir() {
-    const envCodexHome = typeof process.env.CODEX_HOME === 'string' ? process.env.CODEX_HOME.trim() : '';
-    if (envCodexHome) {
-        const target = path.join(envCodexHome, 'skills');
-        return resolveExistingDir([target], target);
-    }
-    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
-    if (xdgConfig) {
-        const target = path.join(xdgConfig, 'codex', 'skills');
-        return resolveExistingDir([target], target);
-    }
-    const homeConfigDir = path.join(os.homedir(), '.config', 'codex', 'skills');
-    return resolveExistingDir([homeConfigDir], CODEX_SKILLS_DIR);
-}
-
-function getClaudeSkillsDir() {
-    const envClaudeHome = typeof process.env.CLAUDE_HOME === 'string' && process.env.CLAUDE_HOME.trim()
-        ? process.env.CLAUDE_HOME.trim()
-        : (typeof process.env.CLAUDE_CONFIG_DIR === 'string' ? process.env.CLAUDE_CONFIG_DIR.trim() : '');
-    if (envClaudeHome) {
-        const target = path.join(envClaudeHome, 'skills');
-        return resolveExistingDir([target], target);
-    }
-    const xdgConfig = typeof process.env.XDG_CONFIG_HOME === 'string' ? process.env.XDG_CONFIG_HOME.trim() : '';
-    if (xdgConfig) {
-        const target = path.join(xdgConfig, 'claude', 'skills');
-        return resolveExistingDir([target], target);
-    }
-    const homeConfigDir = path.join(os.homedir(), '.config', 'claude', 'skills');
-    return resolveExistingDir([homeConfigDir], CLAUDE_SKILLS_DIR);
-}
+function 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;
@@ -212,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) {
@@ -225,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"
@@ -1759,13 +2014,18 @@ function listSkillEntriesByRoot(rootDir) {
     }
 }
 
-function scanUnmanagedSkills(params = {}) {
-    const target = resolveSkillTarget(params);
-    if (!target) {
-        return { error: '目标宿主不支持' };
-    }
-    const targetRoot = resolveCopyTargetRoot(target.dir);
-    const existing = listSkills({ targetApp: target.app });
+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 };
     }
@@ -1773,15 +2033,15 @@ function scanUnmanagedSkills(params = {}) {
         .map((item) => (item && typeof item.name === 'string' ? item.name.trim() : ''))
         .filter(Boolean));
 
-    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 = path.join(targetRoot, entry.name);
-            if (fs.existsSync(targetCandidate)) {
-                continue;
-            }
+    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;
             }
@@ -1824,13 +2084,18 @@ function scanUnmanagedCodexSkills() {
     return scanUnmanagedSkills({ targetApp: 'codex' });
 }
 
-function importSkills(params = {}) {
-    const target = resolveSkillTarget(params);
-    if (!target) {
-        return { error: '目标宿主不支持' };
-    }
-    const targetRoot = resolveCopyTargetRoot(target.dir);
-    const rawItems = Array.isArray(params.items) ? params.items : [];
+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' };
     }
@@ -1873,12 +2138,13 @@ function importSkills(params = {}) {
         }
         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;
@@ -1892,12 +2158,12 @@ function importSkills(params = {}) {
             continue;
         }
 
-        const targetPath = path.join(targetRoot, normalizedName.name);
-        const targetRelative = path.relative(targetRoot, 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;
@@ -2037,13 +2303,19 @@ function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbac
     return normalizeCodexSkillName(candidate);
 }
 
-async function importSkillsFromZipFile(zipPath, options = {}) {
-    const fallbackName = typeof options.fallbackName === 'string' ? options.fallbackName : '';
-    const tempDir = typeof options.tempDir === 'string' ? options.tempDir : '';
-    const imported = [];
-    const failed = [];
-    const dedupNames = new Set();
-    const extractionRoot = path.join(tempDir || path.dirname(zipPath), 'extract');
+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 = '';
 
@@ -2051,11 +2323,12 @@ async function importSkillsFromZipFile(zipPath, options = {}) {
         target = resolveSkillTarget(options, 'codex');
         if (!target) {
             return { error: '目标宿主不支持' };
-        }
-        targetRoot = resolveCopyTargetRoot(target.dir);
-        await inspectZipArchiveLimits(zipPath, {
-            maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
-            maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
+        }
+        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);
@@ -2083,12 +2356,12 @@ async function importSkillsFromZipFile(zipPath, options = {}) {
             }
             dedupNames.add(dedupKey);
 
-            const targetPath = path.join(targetRoot, normalizedName.name);
-            const targetRelative = path.relative(targetRoot, 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;
             }
@@ -2807,358 +3080,11 @@ 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 };
-    }
-
-    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
-    };
-
-    if (!baseProbe.ok) {
-        issues.push({
-            code: 'remote-unreachable',
-            message: `远程探测失败：${baseProbe.error || '无法连接'}`,
-            suggestion: '检查网络与 base_url 可达性'
-        });
-        return { issues, results };
-    }
-
-    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 是否正确'
-        });
-    }
-
-    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
-        };
-
-        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'
-                });
-            }
-
-            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: '切换模型或确认模型名称'
-                    });
-                }
-            }
-        }
-    }
-
-    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: '检查模型名与权限'
-                });
-            }
-        }
-    }
-
-    return { issues, results };
-}
-
 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) {
-            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
-    };
+    return buildConfigHealthReportCore(params, {
+        readConfigOrVirtualDefault,
+        readModels
+    });
 }
 
 function buildDefaultConfigContent(initializedAt) {
@@ -3168,6 +3094,8 @@ function buildDefaultConfigContent(initializedAt) {
 
 model_provider = "openai"
 model = "${defaultModel}"
+model_context_window = ${DEFAULT_MODEL_CONTEXT_WINDOW}
+model_auto_compact_token_limit = ${DEFAULT_MODEL_AUTO_COMPACT_TOKEN_LIMIT}
 
 [model_providers.openai]
 name = "openai"
@@ -3333,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)) {
@@ -3343,6 +3310,20 @@ function getConfigTemplate(params = {}) {
             }
         } catch (e) {}
     }
+    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);
@@ -3352,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()) {
@@ -3370,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' };
     }
@@ -3836,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;
     }
@@ -3846,30 +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);
-}
-
-function resolveCopyTargetRoot(targetDir) {
-    const suffixSegments = [];
-    let current = path.resolve(targetDir || '');
-    while (current && !fs.existsSync(current)) {
-        const parent = path.dirname(current);
-        if (!parent || parent === current) {
-            break;
-        }
-        suffixSegments.unshift(path.basename(current));
-        current = parent;
-    }
-    let resolvedRoot = normalizePathForCompare(current || targetDir);
-    if (!resolvedRoot) {
-        resolvedRoot = path.resolve(targetDir || '');
-    }
-    for (const segment of suffixSegments) {
-        resolvedRoot = path.join(resolvedRoot, segment);
-    }
-    return resolvedRoot;
-}
+    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)) {
@@ -4642,19 +4683,97 @@ function extractMessageFromRecord(record, source) {
         return null;
     }
 
-    const role = normalizeRole(record.type);
-    if (!role) {
-        return null;
+    const role = normalizeRole(record.type);
+    if (!role) {
+        return null;
+    }
+    const content = record.message ? record.message.content : '';
+    const text = extractMessageText(content);
+    if (!text) {
+        return null;
+    }
+    return { role, text };
+}
+
+function createSessionQueryScanState(tokens, options = {}) {
+    const mode = normalizeQueryMode(options.mode);
+    const roleFilter = normalizeRoleFilter(options.roleFilter);
+    const maxMatches = Number.isFinite(Number(options.maxMatches))
+        ? Math.max(1, Number(options.maxMatches))
+        : 1;
+    const snippetLimit = Number.isFinite(Number(options.snippetLimit))
+        ? Math.max(0, Number(options.snippetLimit))
+        : 0;
+
+    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));
     }
-    const content = record.message ? record.message.content : '';
-    const text = extractMessageText(content);
-    if (!text) {
-        return null;
+    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);
     }
-    return { role, text };
+
+    for (const record of records) {
+        const message = extractMessageFromRecord(record, source);
+        if (!message) {
+            continue;
+        }
+        if (consumeSessionQueryMessage(state, message)) {
+            break;
+        }
+    }
+
+    return buildSessionQueryScanResult(state);
 }
 
-function scanSessionContentForQuery(session, tokens, options = {}) {
+async function scanSessionContentForQuery(session, tokens, options = {}) {
     if (!session || !Array.isArray(tokens) || tokens.length === 0) {
         return { hit: false, count: 0, snippets: [] };
     }
@@ -4664,61 +4783,59 @@ function scanSessionContentForQuery(session, tokens, options = {}) {
         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);
-    const mode = normalizeQueryMode(options.mode);
-    const roleFilter = normalizeRoleFilter(options.roleFilter);
-    const maxMatches = Number.isFinite(Number(options.maxMatches))
-        ? Math.max(1, Number(options.maxMatches))
-        : 1;
-    const snippetLimit = Number.isFinite(Number(options.snippetLimit))
-        ? Math.max(0, Number(options.snippetLimit))
+    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 });
 
-    const messages = [];
-    for (const record of records) {
-        const message = extractMessageFromRecord(record, session.source);
-        if (!message || !message.text) {
-            continue;
-        }
-        messages.push(message);
-    }
+        let bytesRead = 0;
+        for await (const line of rl) {
+            if (maxBytes > 0 && bytesRead >= maxBytes) {
+                break;
+            }
 
-    const filteredMessages = roleFilter === 'system'
-        ? messages
-        : removeLeadingSystemMessage(messages);
+            bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
 
-    let count = 0;
-    const snippets = [];
+            let record;
+            try {
+                record = JSON.parse(trimmed);
+            } catch (e) {
+                continue;
+            }
 
-    for (const message of filteredMessages) {
-        if (roleFilter !== 'all' && message.role !== roleFilter) {
-            continue;
-        }
-        if (!matchTokensInText(message.text, tokens, mode)) {
-            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;
@@ -4732,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 = [];
@@ -4750,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,
@@ -5225,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';
@@ -5267,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,
@@ -5303,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)) {
@@ -7480,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 '';
+}
+
+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 timeoutMs = Number.isFinite(options.timeoutMs)
-            ? Math.max(1000, Number(options.timeoutMs))
-            : SPEED_TEST_TIMEOUT_MS;
+    const { config } = readConfigOrVirtualDefault();
+    const providers = config.model_providers || {};
+    const provider = providers[providerName];
+    if (!provider || typeof provider !== 'object') {
+        return { error: `Provider not found: ${providerName}` };
+    }
 
-        const transport = parsed.protocol === 'https:' ? https : http;
-        const headers = {
-            'User-Agent': 'codexmate-speed-test',
-            'Accept': 'application/json'
-        };
-        if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-        }
+    const baseUrl = typeof provider.base_url === 'string' ? provider.base_url.trim() : '';
+    if (!baseUrl) {
+        return { error: `Provider ${providerName} missing URL` };
+    }
 
-        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 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` };
+    }
 
-        req.setTimeout(timeoutMs, () => {
-            req.destroy(new Error('timeout'));
-        });
+    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 };
+    }
+
+    const timeoutMs = Number.isFinite(params.timeoutMs)
+        ? Math.max(1000, Number(params.timeoutMs))
+        : 30000;
+    let finalSpec = target.specs[0];
+    let result = null;
 
-        req.on('error', (err) => {
-            resolve({ ok: false, error: err.message, durationMs: Date.now() - start });
+    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 || '')
+    }));
 }
 
 // ============================================================================
@@ -9753,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);
@@ -9766,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);
@@ -9939,8 +10382,46 @@ async function handleImportSkillsZipUpload(req, res, options = {}) {
     }
 }
 
+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];
@@ -9976,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;
@@ -10173,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':
@@ -10354,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);
@@ -10362,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');
@@ -10434,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);
+            }
         }
     });
 
@@ -10590,6 +11120,7 @@ function cmdStart(options = {}) {
 
     const port = resolveWebPort();
     const host = resolveWebHost(options);
+    releaseRunPortIfNeeded(port, host);
 
     let serverHandle = createWebServer({
         htmlPath,
@@ -11464,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 || '',
@@ -11566,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'],
@@ -11580,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}}'
                 }
             },
             {
@@ -12149,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',
@@ -12157,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
         },