codexmate 0.0.13 → 0.0.15

package/cli.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const toml = require('@iarna/toml');
 const JSON5 = require('json5');
 const zipLib = require('zip-lib');
+const yauzl = require('yauzl');
 const { exec, execSync, spawn, spawnSync } = require('child_process');
 const http = require('http');
 const https = require('https');
@@ -21,6 +22,8 @@ const {
     detectLineEnding,
     normalizeLineEnding,
     isValidProviderName,
+    escapeTomlBasicString,
+    buildModelProviderTableHeader,
     buildModelsCandidates,
     isValidHttpUrl,
     normalizeBaseUrl,
@@ -54,6 +57,10 @@ const {
     resolveMaxMessagesValue
 } = require('./lib/cli-session-utils');
 const { createMcpStdioServer } = require('./lib/mcp-stdio');
+const {
+    validateWorkflowDefinition,
+    executeWorkflowDefinition
+} = require('./lib/workflow-engine');
 
 const DEFAULT_WEB_PORT = 3737;
 const DEFAULT_WEB_HOST = '127.0.0.1';
@@ -78,6 +85,8 @@ const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
 const CLAUDE_PROJECTS_DIR = path.join(os.homedir(), '.claude', 'projects');
 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 CODEX_BACKUP_NAME = 'codex-config';
 
@@ -98,12 +107,24 @@ const SESSION_SCAN_FACTOR = 4;
 const SESSION_SCAN_MIN_FILES = 800;
 const MAX_SESSION_PATH_LIST_SIZE = 2000;
 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_IMPORT_SOURCES = Object.freeze([
+    { app: 'claude', label: 'Claude Code', dir: CLAUDE_SKILLS_DIR },
+    { app: 'agents', label: 'Agents', dir: AGENTS_SKILLS_DIR }
+]);
 const MODELS_CACHE_TTL_MS = 60 * 1000;
 const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
 const MODELS_CACHE_MAX_ENTRIES = 50;
 const MODELS_RESPONSE_MAX_BYTES = 1024 * 1024;
 const MAX_RECENT_CONFIGS = 3;
 const MAX_UPLOAD_SIZE = 200 * 1024 * 1024;
+const MAX_SKILLS_ZIP_UPLOAD_SIZE = 20 * 1024 * 1024;
+const MAX_SKILLS_ZIP_ENTRY_COUNT = 2000;
+const MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES = 512 * 1024 * 1024;
+const DOWNLOAD_ARTIFACT_TTL_MS = 10 * 60 * 1000;
+const g_downloadArtifacts = new Map();
 const BUILTIN_PROXY_PROVIDER_NAME = 'codexmate-proxy';
 const DEFAULT_BUILTIN_PROXY_SETTINGS = Object.freeze({
     enabled: false,
@@ -215,16 +236,50 @@ function ensureConfigDir() {
     }
 }
 
+function createConfigLoadError(type, message, detail) {
+    const err = new Error(detail || message);
+    err.configErrorType = type || 'read';
+    err.configPublicReason = message || '读取 config.toml 失败';
+    err.configDetail = detail || message || '';
+    return err;
+}
+
 function readConfig() {
     if (!fs.existsSync(CONFIG_FILE)) {
-        throw new Error(`配置文件不存在: ${CONFIG_FILE}`);
+        throw createConfigLoadError(
+            'missing',
+            '未检测到 config.toml',
+            `配置文件不存在: ${CONFIG_FILE}`
+        );
+    }
+
+    let content = '';
+    try {
+        content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+    } catch (e) {
+        throw createConfigLoadError(
+            'read',
+            '读取 config.toml 失败',
+            `读取配置文件失败: ${e && e.message ? e.message : e}`
+        );
     }
+
+    let parsed;
     try {
-        const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
-        return toml.parse(content);
+        parsed = toml.parse(content);
     } catch (e) {
-        throw new Error(`配置文件解析失败: ${e.message}`);
+        throw createConfigLoadError(
+            'parse',
+            'config.toml 解析失败',
+            `配置文件解析失败: ${e && e.message ? e.message : e}`
+        );
+    }
+
+    if (isPlainObject(parsed) && isPlainObject(parsed.model_providers)) {
+        const providerHeaderSegmentKeySet = collectModelProviderHeaderSegmentKeySet(content);
+        parsed.model_providers = normalizeLegacyModelProviders(parsed.model_providers, providerHeaderSegmentKeySet);
     }
+    return parsed;
 }
 
 function writeConfig(content) {
@@ -277,6 +332,519 @@ function isPlainObject(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
 }
 
+const PROVIDER_CONFIG_KEYS = new Set([
+    'name',
+    'base_url',
+    'wire_api',
+    'requires_openai_auth',
+    'preferred_auth_method',
+    'request_max_retries',
+    'stream_max_retries',
+    'stream_idle_timeout_ms'
+]);
+const RECOVERABLE_PROVIDER_SIGNAL_KEYS = [...PROVIDER_CONFIG_KEYS].filter((key) => key !== 'name' && key !== 'base_url');
+
+function looksLikeProviderConfig(value) {
+    if (!isPlainObject(value)) return false;
+    return Object.keys(value).some((key) => PROVIDER_CONFIG_KEYS.has(key));
+}
+
+function isRecoverableNestedProviderConfig(value) {
+    if (!isPlainObject(value)) return false;
+    const hasBaseUrl = typeof value.base_url === 'string' && value.base_url.trim() !== '';
+    if (!hasBaseUrl) return false;
+    const hasName = typeof value.name === 'string' && value.name.trim() !== '';
+    const hasProviderSignals = RECOVERABLE_PROVIDER_SIGNAL_KEYS.some((key) => Object.prototype.hasOwnProperty.call(value, key));
+    return hasName || hasProviderSignals;
+}
+
+function collectNestedProviderConfigs(node, pathSegments, collector) {
+    if (!isPlainObject(node)) return;
+    const segments = Array.isArray(pathSegments) ? pathSegments : [String(pathSegments || '')];
+    const lastSegment = segments.length > 0 ? segments[segments.length - 1] : '';
+    if (segments.length > 1 && lastSegment === 'metadata') {
+        return;
+    }
+    if (isRecoverableNestedProviderConfig(node)) {
+        collector.push({
+            name: segments.join('.'),
+            segments: segments.slice(),
+            provider: node
+        });
+    }
+    for (const [childKey, childValue] of Object.entries(node)) {
+        if (!isPlainObject(childValue)) continue;
+        collectNestedProviderConfigs(childValue, [...segments, childKey], collector);
+    }
+}
+
+function normalizeLegacySegments(segments) {
+    if (!Array.isArray(segments) || segments.length === 0) return null;
+    return segments.map((item) => String(item));
+}
+
+function buildLegacySegmentsKey(segments) {
+    const normalized = normalizeLegacySegments(segments);
+    return normalized ? JSON.stringify(normalized) : '';
+}
+
+function appendLegacySegmentsVariant(provider, segments) {
+    if (!isPlainObject(provider)) return;
+    const normalized = normalizeLegacySegments(segments);
+    if (!normalized) return;
+
+    const variants = [];
+    const seen = new Set();
+    const pushVariant = (candidate) => {
+        const key = buildLegacySegmentsKey(candidate);
+        if (!key || seen.has(key)) return;
+        seen.add(key);
+        variants.push(normalizeLegacySegments(candidate));
+    };
+
+    if (Array.isArray(provider.__codexmate_legacy_segments)) {
+        pushVariant(provider.__codexmate_legacy_segments);
+    }
+    if (Array.isArray(provider.__codexmate_legacy_segment_variants)) {
+        for (const candidate of provider.__codexmate_legacy_segment_variants) {
+            pushVariant(candidate);
+        }
+    }
+    pushVariant(normalized);
+
+    try {
+        if (!Array.isArray(provider.__codexmate_legacy_segments)) {
+            Object.defineProperty(provider, '__codexmate_legacy_segments', {
+                value: normalized,
+                enumerable: false,
+                configurable: true,
+                writable: true
+            });
+        }
+        Object.defineProperty(provider, '__codexmate_legacy_segment_variants', {
+            value: variants,
+            enumerable: false,
+            configurable: true,
+            writable: true
+        });
+    } catch (e) {}
+}
+
+function setLegacySegmentsMetadata(provider, segments) {
+    appendLegacySegmentsVariant(provider, segments);
+}
+
+function normalizeLegacyModelProviders(modelProviders, providerHeaderSegmentKeySet = null) {
+    if (!isPlainObject(modelProviders)) {
+        return modelProviders;
+    }
+
+    let changed = false;
+    const normalized = {};
+    const addRecovered = (entry) => {
+        const name = entry && typeof entry.name === 'string' ? entry.name : '';
+        const segments = entry && Array.isArray(entry.segments) ? entry.segments.slice() : null;
+        const provider = entry ? entry.provider : null;
+        if (!name || !isPlainObject(provider)) return;
+        const segmentKey = buildLegacySegmentsKey(segments);
+        if (providerHeaderSegmentKeySet instanceof Set && segmentKey && !providerHeaderSegmentKeySet.has(segmentKey)) {
+            return;
+        }
+        const existing = Object.prototype.hasOwnProperty.call(normalized, name)
+            ? normalized[name]
+            : (Object.prototype.hasOwnProperty.call(modelProviders, name) ? modelProviders[name] : null);
+        if (isPlainObject(existing)) {
+            if (!Array.isArray(existing.__codexmate_legacy_segments)) {
+                setLegacySegmentsMetadata(existing, [name]);
+            }
+            appendLegacySegmentsVariant(existing, segments);
+            return;
+        }
+        if (Object.prototype.hasOwnProperty.call(modelProviders, name)) return;
+        if (Object.prototype.hasOwnProperty.call(normalized, name)) return;
+        setLegacySegmentsMetadata(provider, segments);
+        normalized[name] = provider;
+        changed = true;
+    };
+
+    for (const [name, provider] of Object.entries(modelProviders)) {
+        normalized[name] = provider;
+        if (!isPlainObject(provider)) continue;
+
+        if (looksLikeProviderConfig(provider)) {
+            setLegacySegmentsMetadata(provider, [name]);
+            for (const [childKey, childValue] of Object.entries(provider)) {
+                if (!isPlainObject(childValue)) continue;
+                const recovered = [];
+                collectNestedProviderConfigs(childValue, [name, childKey], recovered);
+                for (const recoveredEntry of recovered) {
+                    addRecovered(recoveredEntry);
+                }
+            }
+            continue;
+        }
+
+        const recovered = [];
+        collectNestedProviderConfigs(provider, [name], recovered);
+        delete normalized[name];
+        changed = true;
+        for (const recoveredEntry of recovered) {
+            addRecovered(recoveredEntry);
+        }
+    }
+
+    return changed ? normalized : modelProviders;
+}
+
+function escapeRegex(value) {
+    return String(value || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function areStringArraysEqual(a, b) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+        if (String(a[i]) !== String(b[i])) return false;
+    }
+    return true;
+}
+
+function parseTomlDottedKeyExpression(expression) {
+    const text = String(expression || '');
+    let index = 0;
+    const segments = [];
+    const skipWhitespace = () => {
+        while (index < text.length && /\s/.test(text[index])) index++;
+    };
+
+    while (index < text.length) {
+        skipWhitespace();
+        if (index >= text.length) break;
+
+        const ch = text[index];
+        if (ch === "'") {
+            const end = text.indexOf("'", index + 1);
+            if (end === -1) return null;
+            segments.push(text.slice(index + 1, end));
+            index = end + 1;
+        } else if (ch === '"') {
+            index += 1;
+            let value = '';
+            let closed = false;
+            while (index < text.length) {
+                const cur = text[index];
+                if (cur === '"') {
+                    index += 1;
+                    closed = true;
+                    break;
+                }
+                if (cur !== '\\') {
+                    value += cur;
+                    index += 1;
+                    continue;
+                }
+                if (index + 1 >= text.length) return null;
+                const esc = text[index + 1];
+                if (esc === 'u' || esc === 'U') {
+                    const hexLen = esc === 'u' ? 4 : 8;
+                    const hex = text.slice(index + 2, index + 2 + hexLen);
+                    if (!/^[0-9a-fA-F]+$/.test(hex)) return null;
+                    try {
+                        value += String.fromCodePoint(parseInt(hex, 16));
+                    } catch (e) {
+                        return null;
+                    }
+                    index += 2 + hexLen;
+                    continue;
+                }
+                const unescaped = {
+                    b: '\b',
+                    t: '\t',
+                    n: '\n',
+                    f: '\f',
+                    r: '\r',
+                    '"': '"',
+                    '\\': '\\'
+                }[esc];
+                if (unescaped === undefined) return null;
+                value += unescaped;
+                index += 2;
+            }
+            if (!closed) return null;
+            segments.push(value);
+        } else {
+            const start = index;
+            while (index < text.length && !/\s|\./.test(text[index])) index++;
+            const bare = text.slice(start, index);
+            if (!bare) return null;
+            segments.push(bare);
+        }
+
+        skipWhitespace();
+        if (index >= text.length) break;
+        if (text[index] !== '.') return null;
+        index += 1;
+    }
+
+    return segments.length > 0 ? segments : null;
+}
+
+function collectTomlMultilineStringRanges(text) {
+    const source = typeof text === 'string' ? text : '';
+    const ranges = [];
+    let i = 0;
+    let inMultilineBasic = false;
+    let inMultilineLiteral = false;
+    let rangeStart = -1;
+
+    while (i < source.length) {
+        if (inMultilineBasic) {
+            if (source.slice(i, i + 3) === '"""') {
+                let slashCount = 0;
+                for (let j = i - 1; j >= 0 && source[j] === '\\'; j--) {
+                    slashCount++;
+                }
+                if (slashCount % 2 === 0) {
+                    let runEnd = i + 3;
+                    while (runEnd < source.length && source[runEnd] === '"') runEnd++;
+                    ranges.push({ start: rangeStart, end: runEnd });
+                    inMultilineBasic = false;
+                    rangeStart = -1;
+                    i = runEnd;
+                    continue;
+                }
+            }
+            i++;
+            continue;
+        }
+
+        if (inMultilineLiteral) {
+            if (source.slice(i, i + 3) === "'''") {
+                let runEnd = i + 3;
+                while (runEnd < source.length && source[runEnd] === '\'') runEnd++;
+                ranges.push({ start: rangeStart, end: runEnd });
+                inMultilineLiteral = false;
+                rangeStart = -1;
+                i = runEnd;
+                continue;
+            }
+            i++;
+            continue;
+        }
+
+        const ch = source[i];
+        if (ch === '#') {
+            while (i < source.length && source[i] !== '\n') i++;
+            continue;
+        }
+
+        if (source.slice(i, i + 3) === '"""') {
+            inMultilineBasic = true;
+            rangeStart = i;
+            i += 3;
+            continue;
+        }
+
+        if (source.slice(i, i + 3) === "'''") {
+            inMultilineLiteral = true;
+            rangeStart = i;
+            i += 3;
+            continue;
+        }
+
+        if (ch === '"') {
+            i++;
+            while (i < source.length) {
+                if (source[i] === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (source[i] === '"' || source[i] === '\n') {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+
+        if (ch === '\'') {
+            i++;
+            while (i < source.length) {
+                if (source[i] === '\'' || source[i] === '\n') {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+
+        i++;
+    }
+
+    if (rangeStart >= 0) {
+        ranges.push({ start: rangeStart, end: source.length });
+    }
+    return ranges;
+}
+
+function isIndexInRanges(index, ranges) {
+    for (const range of ranges) {
+        if (index < range.start) return false;
+        if (index >= range.start && index < range.end) return true;
+    }
+    return false;
+}
+
+function findProviderSectionRanges(content, providerName, exactSegments = null) {
+    const text = typeof content === 'string' ? content : '';
+    const name = typeof providerName === 'string' ? providerName.trim() : '';
+    const targetSegments = Array.isArray(exactSegments) ? exactSegments.map((item) => String(item)) : null;
+    if (!text || !name) return [];
+
+    const safeName = escapeRegex(name);
+    const headerPatterns = [
+        { priority: 0, regex: new RegExp(`^\\s*model_providers\\s*\\.\\s*"${safeName}"\\s*$`) },
+        { priority: 1, regex: new RegExp(`^\\s*model_providers\\s*\\.\\s*'${safeName}'\\s*$`) },
+        { priority: 2, regex: new RegExp(`^\\s*model_providers\\s*\\.\\s*${safeName}\\s*$`) }
+    ];
+
+    const allHeaders = [];
+    const targetPriorityByStart = new Map();
+    const multilineStringRanges = collectTomlMultilineStringRanges(text);
+    const sectionLineRegex = /^[ \t]*\[(?!\[)([^\]\n]+)\][ \t]*(?:#.*)?$/gm;
+    let match;
+    while ((match = sectionLineRegex.exec(text)) !== null) {
+        const start = match.index;
+        if (isIndexInRanges(start, multilineStringRanges)) {
+            continue;
+        }
+        allHeaders.push(start);
+        const headerExpr = String(match[1] || '').trim();
+
+        const parsedSegments = parseTomlDottedKeyExpression(headerExpr);
+        if (Array.isArray(parsedSegments) && parsedSegments.length >= 2 && parsedSegments[0] === 'model_providers') {
+            const providerSegments = parsedSegments.slice(1);
+            if (targetSegments && targetSegments.length > 0 && areStringArraysEqual(providerSegments, targetSegments)) {
+                const prev = targetPriorityByStart.get(start);
+                if (prev === undefined || -3 < prev) {
+                    targetPriorityByStart.set(start, -3);
+                }
+                continue;
+            }
+            if (!targetSegments || targetSegments.length === 0) {
+                const parsedName = providerSegments.join('.');
+                if (parsedName === name) {
+                    const prev = targetPriorityByStart.get(start);
+                    if (prev === undefined || -2 < prev) {
+                        targetPriorityByStart.set(start, -2);
+                    }
+                    continue;
+                }
+            }
+        }
+
+        for (const pattern of headerPatterns) {
+            if (pattern.regex.test(headerExpr)) {
+                const prev = targetPriorityByStart.get(start);
+                if (prev === undefined || pattern.priority < prev) {
+                    targetPriorityByStart.set(start, pattern.priority);
+                }
+                break;
+            }
+        }
+    }
+
+    if (targetPriorityByStart.size === 0) {
+        return [];
+    }
+
+    const ranges = [];
+    for (let i = 0; i < allHeaders.length; i++) {
+        const start = allHeaders[i];
+        if (!targetPriorityByStart.has(start)) continue;
+        const end = i + 1 < allHeaders.length ? allHeaders[i + 1] : text.length;
+        ranges.push({
+            start,
+            end,
+            priority: targetPriorityByStart.get(start)
+        });
+    }
+    const exactMatches = ranges.filter((range) => range.priority === -3);
+    return exactMatches.length > 0 ? exactMatches : ranges;
+}
+
+function doesSegmentsStartWith(segments, prefix) {
+    if (!Array.isArray(segments) || !Array.isArray(prefix) || prefix.length === 0 || segments.length < prefix.length) {
+        return false;
+    }
+    for (let i = 0; i < prefix.length; i++) {
+        if (String(segments[i]) !== String(prefix[i])) return false;
+    }
+    return true;
+}
+
+function findProviderDescendantSectionRanges(content, prefixSegments) {
+    const text = typeof content === 'string' ? content : '';
+    const prefix = Array.isArray(prefixSegments) ? prefixSegments.map((item) => String(item)) : [];
+    if (!text || prefix.length === 0) return [];
+
+    const allHeaders = [];
+    const parsedProviderSegmentsByStart = new Map();
+    const multilineStringRanges = collectTomlMultilineStringRanges(text);
+    const sectionLineRegex = /^[ \t]*\[(?!\[)([^\]\n]+)\][ \t]*(?:#.*)?$/gm;
+    let match;
+    while ((match = sectionLineRegex.exec(text)) !== null) {
+        const start = match.index;
+        if (isIndexInRanges(start, multilineStringRanges)) {
+            continue;
+        }
+        allHeaders.push(start);
+        const headerExpr = String(match[1] || '').trim();
+        const parsedSegments = parseTomlDottedKeyExpression(headerExpr);
+        if (!Array.isArray(parsedSegments) || parsedSegments.length < 2 || parsedSegments[0] !== 'model_providers') {
+            continue;
+        }
+        parsedProviderSegmentsByStart.set(start, parsedSegments.slice(1));
+    }
+
+    const ranges = [];
+    for (let i = 0; i < allHeaders.length; i++) {
+        const start = allHeaders[i];
+        const providerSegments = parsedProviderSegmentsByStart.get(start);
+        if (!providerSegments) continue;
+        if (!doesSegmentsStartWith(providerSegments, prefix)) continue;
+        if (providerSegments.length <= prefix.length) continue;
+        const end = i + 1 < allHeaders.length ? allHeaders[i + 1] : text.length;
+        ranges.push({ start, end, priority: 0 });
+    }
+    return ranges;
+}
+
+function collectModelProviderHeaderSegmentKeySet(content) {
+    const text = typeof content === 'string' ? content : '';
+    const keys = new Set();
+    if (!text) return keys;
+
+    const multilineStringRanges = collectTomlMultilineStringRanges(text);
+    const sectionLineRegex = /^[ \t]*\[(?!\[)([^\]\n]+)\][ \t]*(?:#.*)?$/gm;
+    let match;
+    while ((match = sectionLineRegex.exec(text)) !== null) {
+        const start = match.index;
+        if (isIndexInRanges(start, multilineStringRanges)) {
+            continue;
+        }
+        const headerExpr = String(match[1] || '').trim();
+        const parsedSegments = parseTomlDottedKeyExpression(headerExpr);
+        if (!Array.isArray(parsedSegments) || parsedSegments.length < 2 || parsedSegments[0] !== 'model_providers') {
+            continue;
+        }
+        const key = buildLegacySegmentsKey(parsedSegments.slice(1));
+        if (key) keys.add(key);
+    }
+    return keys;
+}
+
 function normalizeAuthProfileName(value) {
     const raw = typeof value === 'string' ? value.trim() : '';
     if (!raw) return '';
@@ -656,138 +1224,981 @@ async function fetchModelsFromBaseUrl(baseUrl, apiKey) {
     promise.finally(() => {
         g_modelsInFlight.delete(cacheKey);
     });
-    return promise;
+    return promise;
+}
+
+async function fetchModelsFromBaseUrlCore(baseUrl, apiKey) {
+    const candidates = buildModelsCandidates(baseUrl);
+    if (candidates.length === 0) return { error: 'Provider missing URL' };
+
+    let lastError = '';
+    for (const modelsUrl of candidates) {
+        let parsed;
+        try {
+            parsed = new URL(modelsUrl);
+        } catch (e) {
+            lastError = 'Invalid URL';
+            continue;
+        }
+
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const agent = parsed.protocol === 'https:' ? HTTPS_KEEP_ALIVE_AGENT : HTTP_KEEP_ALIVE_AGENT;
+        const headers = {
+            'User-Agent': 'codexmate-models',
+            'Accept': 'application/json'
+        };
+        if (apiKey) {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+            headers['x-api-key'] = apiKey;
+        }
+
+        const result = await new Promise((innerResolve) => {
+            let settled = false;
+            const finish = (payload) => {
+                if (settled) return;
+                settled = true;
+                innerResolve(payload);
+            };
+            const req = transport.request(parsed, { method: 'GET', headers, agent }, (res) => {
+                const status = res.statusCode || 0;
+                const contentType = String(res.headers['content-type'] || '').toLowerCase();
+                if (status === 404 || status === 405 || status === 501) {
+                    res.resume();
+                    return finish({ unavailable: true });
+                }
+                let body = '';
+                let receivedBytes = 0;
+                res.on('data', chunk => {
+                    receivedBytes += chunk.length || 0;
+                    if (receivedBytes > MODELS_RESPONSE_MAX_BYTES) {
+                        res.destroy();
+                        return finish({ unavailable: true });
+                    }
+                    body += chunk;
+                });
+                res.on('end', () => {
+                    if (settled) return;
+                    if (status >= 400) {
+                        return finish({ error: `Request failed: ${status}` });
+                    }
+                    if (contentType && !contentType.includes('application/json')) {
+                        return finish({ unavailable: true });
+                    }
+                    try {
+                        const payload = JSON.parse(body || '{}');
+                        if (!hasModelsListPayload(payload)) {
+                            return finish({ unavailable: true });
+                        }
+                        const models = extractModelNames(payload);
+                        return finish({ models });
+                    } catch (e) {
+                        return finish({ unavailable: true });
+                    }
+                });
+            });
+
+            req.setTimeout(SPEED_TEST_TIMEOUT_MS, () => {
+                req.destroy(new Error('timeout'));
+            });
+            req.on('error', (err) => {
+                finish({ error: err.message || 'Request failed' });
+            });
+            req.end();
+        });
+
+        if (result && Array.isArray(result.models)) {
+            return { models: result.models };
+        }
+        if (result && result.error) {
+            lastError = result.error;
+            continue;
+        }
+    }
+
+    if (lastError) {
+        return { error: lastError };
+    }
+    return { unlimited: true };
+}
+
+async function fetchProviderModels(providerName, overrides = {}) {
+    const { config } = readConfigOrVirtualDefault();
+    const targetProvider = providerName || config.model_provider || '';
+    if (!targetProvider) return { error: '未设置当前提供商' };
+
+    const providers = config.model_providers || {};
+    const provider = providers[targetProvider];
+    if (!provider) return { error: `提供商不存在: ${targetProvider}` };
+
+    const baseUrl = overrides.baseUrl || provider.base_url || '';
+    const apiKey = overrides.apiKey ?? provider.preferred_auth_method ?? '';
+    const res = await fetchModelsFromBaseUrl(baseUrl, apiKey);
+    if (res.unlimited) return { models: [], provider: targetProvider, unlimited: true };
+    if (res.error) return { error: res.error };
+    return { models: res.models || [], provider: targetProvider, unlimited: false };
+}
+
+function resolveAgentsFilePath(params = {}) {
+    const baseDir = typeof params.baseDir === 'string' && params.baseDir.trim()
+        ? params.baseDir.trim()
+        : CONFIG_DIR;
+    return path.join(baseDir, AGENTS_FILE_NAME);
+}
+
+function validateAgentsBaseDir(filePath) {
+    const dirPath = path.dirname(filePath);
+    try {
+        const stat = fs.statSync(dirPath);
+        if (!stat.isDirectory()) {
+            return { error: `目标不是目录: ${dirPath}` };
+        }
+    } catch (e) {
+        return { error: `目标目录不存在: ${dirPath}` };
+    }
+    return { ok: true, dirPath };
+}
+
+function normalizeCodexSkillName(name) {
+    const value = typeof name === 'string' ? name.trim() : '';
+    if (!value) {
+        return { error: '技能名称不能为空' };
+    }
+    if (value.includes('\0')) {
+        return { error: '技能名称非法' };
+    }
+    if (value === '.' || value === '..') {
+        return { error: '技能名称非法' };
+    }
+    if (value.includes('/') || value.includes('\\')) {
+        return { error: '技能名称非法' };
+    }
+    if (path.basename(value) !== value) {
+        return { error: '技能名称非法' };
+    }
+    if (value.startsWith('.')) {
+        return { error: '系统技能不可删除' };
+    }
+    return { name: value };
+}
+
+function isSkillDirectoryEntry(entryName) {
+    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+    try {
+        const stat = fs.statSync(targetPath);
+        return stat.isDirectory();
+    } catch (e) {
+        return false;
+    }
+}
+
+function normalizeSkillImportSourceApp(app) {
+    const value = typeof app === 'string' ? app.trim().toLowerCase() : '';
+    return SKILL_IMPORT_SOURCES.some((item) => item.app === value) ? value : '';
+}
+
+function getSkillImportSourceByApp(app) {
+    const normalizedApp = normalizeSkillImportSourceApp(app);
+    if (!normalizedApp) return null;
+    return SKILL_IMPORT_SOURCES.find((item) => item.app === normalizedApp) || null;
+}
+
+function parseSimpleSkillFrontmatter(content = '') {
+    const normalized = String(content || '').replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---\n')) {
+        return {};
+    }
+    const endIndex = normalized.indexOf('\n---\n', 4);
+    if (endIndex <= 4) {
+        return {};
+    }
+    const frontmatterRaw = normalized.slice(4, endIndex);
+    const result = {};
+    const lines = frontmatterRaw.split('\n');
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        const line = lines[lineIndex];
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        const matched = trimmed.match(/^([A-Za-z0-9_-]+)\s*:\s*(.*)$/);
+        if (!matched) continue;
+        const key = matched[1];
+        let value = matched[2] || '';
+        const indicator = value.trim();
+        if (/^[>|]/.test(indicator)) {
+            const blockLines = [];
+            let cursor = lineIndex + 1;
+            while (cursor < lines.length) {
+                const candidateLine = lines[cursor];
+                if (!candidateLine.trim()) {
+                    blockLines.push('');
+                    cursor += 1;
+                    continue;
+                }
+                if (/^\s/.test(candidateLine)) {
+                    blockLines.push(candidateLine);
+                    cursor += 1;
+                    continue;
+                }
+                break;
+            }
+            lineIndex = cursor - 1;
+            const indents = blockLines
+                .filter((item) => item.trim())
+                .map((item) => {
+                    const indentMatch = item.match(/^[ \t]*/);
+                    return indentMatch ? indentMatch[0].length : 0;
+                });
+            const commonIndent = indents.length ? Math.min(...indents) : 0;
+            const deindented = blockLines.map((item) => {
+                if (!item.trim()) return '';
+                return item.slice(commonIndent);
+            });
+            if (indicator.startsWith('>')) {
+                const paragraphs = [];
+                let paragraphLines = [];
+                for (const blockLine of deindented) {
+                    const blockTrimmed = blockLine.trim();
+                    if (!blockTrimmed) {
+                        if (paragraphLines.length) {
+                            paragraphs.push(paragraphLines.join(' '));
+                            paragraphLines = [];
+                        }
+                        continue;
+                    }
+                    paragraphLines.push(blockTrimmed);
+                }
+                if (paragraphLines.length) {
+                    paragraphs.push(paragraphLines.join(' '));
+                }
+                value = paragraphs.join('\n');
+            } else {
+                value = deindented.join('\n');
+            }
+        }
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value.trim();
+    }
+    return result;
+}
+
+function stripMarkdownFrontmatter(content = '') {
+    const normalized = String(content || '').replace(/\r\n/g, '\n');
+    if (!normalized.startsWith('---\n')) {
+        return normalized;
+    }
+    const endIndex = normalized.indexOf('\n---\n', 4);
+    if (endIndex <= 4) {
+        return normalized;
+    }
+    return normalized.slice(endIndex + 5);
+}
+
+function extractSkillDescriptionFromMarkdown(content = '') {
+    const normalized = String(content || '').replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    let inFence = false;
+    for (const line of lines) {
+        const trimmedStart = line.trimStart();
+        if (trimmedStart.startsWith('```')) {
+            inFence = !inFence;
+            continue;
+        }
+        if (inFence) continue;
+        if (/^( {4}|\t)/.test(line)) continue;
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        if (trimmed.startsWith('#')) continue;
+        if (trimmed.startsWith('---')) continue;
+        if (/^([A-Za-z0-9_-]+)\s*:\s*/.test(trimmed)) continue;
+        return trimmed.slice(0, 200);
+    }
+    return '';
+}
+
+function readCodexSkillMetadata(skillPath) {
+    const skillFile = path.join(skillPath, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+        return {
+            hasSkillFile: false,
+            displayName: '',
+            description: ''
+        };
+    }
+    try {
+        const raw = fs.readFileSync(skillFile, 'utf-8');
+        const content = stripUtf8Bom(raw);
+        const frontmatter = parseSimpleSkillFrontmatter(content);
+        const contentWithoutFrontmatter = stripMarkdownFrontmatter(content);
+        const heading = contentWithoutFrontmatter.match(/^\s*#\s+(.+)$/m);
+        const displayName = typeof frontmatter.name === 'string' && frontmatter.name.trim()
+            ? frontmatter.name.trim()
+            : (heading && heading[1] ? heading[1].trim() : '');
+        const description = typeof frontmatter.description === 'string' && frontmatter.description.trim()
+            ? frontmatter.description.trim().slice(0, 200)
+            : extractSkillDescriptionFromMarkdown(contentWithoutFrontmatter);
+        return {
+            hasSkillFile: true,
+            displayName,
+            description
+        };
+    } catch (e) {
+        return {
+            hasSkillFile: false,
+            displayName: '',
+            description: ''
+        };
+    }
+}
+
+function getCodexSkillEntryInfoByName(entryName) {
+    const targetPath = path.join(CODEX_SKILLS_DIR, entryName);
+    const normalized = normalizeCodexSkillName(entryName);
+    if (normalized.error) {
+        return null;
+    }
+    const relativePath = path.relative(CODEX_SKILLS_DIR, targetPath);
+    if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+        return null;
+    }
+
+    try {
+        const lstat = fs.lstatSync(targetPath);
+        const isSymbolicLink = lstat.isSymbolicLink();
+        if (!lstat.isDirectory() && !isSymbolicLink) {
+            return null;
+        }
+        if (isSymbolicLink && !isSkillDirectoryEntry(entryName)) {
+            return null;
+        }
+        const metadata = readCodexSkillMetadata(targetPath);
+        return {
+            name: entryName,
+            path: targetPath,
+            hasSkillFile: !!metadata.hasSkillFile,
+            displayName: metadata.displayName || entryName,
+            description: metadata.description || '',
+            sourceType: isSymbolicLink ? 'symlink' : 'directory',
+            updatedAt: Number.isFinite(lstat.mtimeMs) ? Math.floor(lstat.mtimeMs) : 0
+        };
+    } catch (e) {
+        return null;
+    }
+}
+
+function listCodexSkills() {
+    if (!fs.existsSync(CODEX_SKILLS_DIR)) {
+        return {
+            root: CODEX_SKILLS_DIR,
+            exists: false,
+            items: []
+        };
+    }
+    try {
+        const entries = fs.readdirSync(CODEX_SKILLS_DIR, { withFileTypes: true });
+        const items = entries
+            .map((entry) => {
+                const name = entry && entry.name ? entry.name : '';
+                if (!name || name.startsWith('.')) return null;
+                return getCodexSkillEntryInfoByName(name);
+            })
+            .filter(Boolean)
+            .sort((a, b) => a.displayName.localeCompare(b.displayName, 'zh-Hans-CN'));
+        return {
+            root: CODEX_SKILLS_DIR,
+            exists: true,
+            items
+        };
+    } catch (e) {
+        return { error: `读取 skills 目录失败: ${e.message}` };
+    }
+}
+
+function listSkillEntriesByRoot(rootDir) {
+    if (!rootDir || !fs.existsSync(rootDir)) {
+        return [];
+    }
+    try {
+        const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+        return entries
+            .map((entry) => {
+                const name = entry && entry.name ? entry.name : '';
+                if (!name || name.startsWith('.')) return null;
+                const normalized = normalizeCodexSkillName(name);
+                if (normalized.error) return null;
+                const skillPath = path.join(rootDir, name);
+                const relativePath = path.relative(rootDir, skillPath);
+                if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+                    return null;
+                }
+                try {
+                    const lstat = fs.lstatSync(skillPath);
+                    const isSymbolicLink = lstat.isSymbolicLink();
+                    if (!lstat.isDirectory() && !isSymbolicLink) {
+                        return null;
+                    }
+                    if (isSymbolicLink) {
+                        const realPath = fs.realpathSync(skillPath);
+                        const realStat = fs.statSync(realPath);
+                        if (!realStat.isDirectory()) {
+                            return null;
+                        }
+                    }
+                    return {
+                        name,
+                        path: skillPath,
+                        sourceType: isSymbolicLink ? 'symlink' : 'directory'
+                    };
+                } catch (e) {
+                    return null;
+                }
+            })
+            .filter(Boolean);
+    } catch (e) {
+        return [];
+    }
+}
+
+function scanUnmanagedCodexSkills() {
+    const existing = listCodexSkills();
+    if (existing.error) {
+        return { error: existing.error };
+    }
+    const existingNames = new Set((Array.isArray(existing.items) ? existing.items : [])
+        .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) {
+            if (existingNames.has(entry.name)) {
+                continue;
+            }
+            const metadata = readCodexSkillMetadata(entry.path);
+            items.push({
+                key: `${source.app}:${entry.name}`,
+                name: entry.name,
+                displayName: metadata.displayName || entry.name,
+                description: metadata.description || '',
+                sourceApp: source.app,
+                sourceLabel: source.label,
+                sourcePath: entry.path,
+                sourceType: entry.sourceType,
+                hasSkillFile: !!metadata.hasSkillFile
+            });
+        }
+    }
+
+    items.sort((a, b) => {
+        const nameCompare = a.displayName.localeCompare(b.displayName, 'zh-Hans-CN');
+        if (nameCompare !== 0) return nameCompare;
+        return a.sourceLabel.localeCompare(b.sourceLabel, 'zh-Hans-CN');
+    });
+
+    return {
+        root: CODEX_SKILLS_DIR,
+        items,
+        sources: SKILL_IMPORT_SOURCES.map((source) => ({
+            app: source.app,
+            label: source.label,
+            path: source.dir,
+            exists: fs.existsSync(source.dir)
+        }))
+    };
+}
+
+function importCodexSkills(params = {}) {
+    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();
+
+    for (const rawItem of rawItems) {
+        const safeItem = rawItem && typeof rawItem === 'object' ? rawItem : {};
+        const normalizedName = normalizeCodexSkillName(safeItem.name);
+        if (normalizedName.error) {
+            failed.push({
+                name: safeItem && safeItem.name ? String(safeItem.name) : '',
+                sourceApp: safeItem && safeItem.sourceApp ? String(safeItem.sourceApp) : '',
+                error: normalizedName.error
+            });
+            continue;
+        }
+        const source = getSkillImportSourceByApp(safeItem.sourceApp);
+        if (!source) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: safeItem && safeItem.sourceApp ? String(safeItem.sourceApp) : '',
+                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,
+                error: '来源路径非法'
+            });
+            continue;
+        }
+        if (!fs.existsSync(sourcePath)) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                error: '来源 skill 不存在'
+            });
+            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,
+                error: '目标路径非法'
+            });
+            continue;
+        }
+        if (fs.existsSync(targetPath)) {
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                error: 'Codex 中已存在同名 skill'
+            });
+            continue;
+        }
+
+        let copiedToTarget = false;
+        try {
+            const lstat = fs.lstatSync(sourcePath);
+            if (!lstat.isDirectory() && !lstat.isSymbolicLink()) {
+                failed.push({
+                    name: normalizedName.name,
+                    sourceApp: source.app,
+                    error: '来源不是技能目录'
+                });
+                continue;
+            }
+            const sourceDirForCopy = lstat.isSymbolicLink() ? fs.realpathSync(sourcePath) : sourcePath;
+            const sourceStat = fs.statSync(sourceDirForCopy);
+            if (!sourceStat.isDirectory()) {
+                failed.push({
+                    name: normalizedName.name,
+                    sourceApp: source.app,
+                    error: '来源 skill 无法读取'
+                });
+                continue;
+            }
+            const visitedRealPaths = new Set([sourceDirForCopy]);
+            copyDirRecursive(sourceDirForCopy, targetPath, {
+                dereferenceSymlinks: true,
+                allowedRootRealPath: sourceDirForCopy,
+                visitedRealPaths
+            });
+            copiedToTarget = true;
+            imported.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                sourceLabel: source.label,
+                path: targetPath
+            });
+        } catch (e) {
+            if (!copiedToTarget && fs.existsSync(targetPath)) {
+                try {
+                    removeDirectoryRecursive(targetPath);
+                } catch (_) {}
+            }
+            failed.push({
+                name: normalizedName.name,
+                sourceApp: source.app,
+                error: e && e.message ? e.message : '导入失败'
+            });
+        }
+    }
+
+    return {
+        success: failed.length === 0,
+        imported,
+        failed,
+        root: CODEX_SKILLS_DIR
+    };
+}
+
+function collectSkillDirectoriesFromRoot(rootDir, limit = MAX_SKILLS_ZIP_ENTRY_COUNT) {
+    const results = [];
+    let truncated = false;
+    if (!rootDir || !fs.existsSync(rootDir)) {
+        return { results, truncated };
+    }
+    const normalizedLimit = Number.isFinite(limit) && limit > 0
+        ? Math.floor(limit)
+        : MAX_SKILLS_ZIP_ENTRY_COUNT;
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        if (results.length >= normalizedLimit) {
+            truncated = true;
+            break;
+        }
+        const currentDir = stack.pop();
+        let entries = [];
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        } catch (e) {
+            continue;
+        }
+
+        const hasSkillFile = entries.some((entry) => entry && entry.isFile() && String(entry.name || '') === 'SKILL.md');
+        if (hasSkillFile) {
+            results.push(currentDir);
+            continue;
+        }
+
+        for (const entry of entries) {
+            if (!entry || !entry.isDirectory()) continue;
+            const entryName = typeof entry.name === 'string' ? entry.name.trim() : '';
+            if (!entryName || entryName.startsWith('.')) {
+                continue;
+            }
+            stack.push(path.join(currentDir, entryName));
+        }
+    }
+    return { results, truncated };
+}
+
+function resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName = '') {
+    const directoryBaseName = path.basename(skillDir || '');
+    const extractionBaseName = path.basename(extractionRoot || '');
+    let candidate = directoryBaseName;
+    if (!candidate || candidate === extractionBaseName || candidate.startsWith('.')) {
+        const fallback = typeof fallbackName === 'string' ? fallbackName.trim() : '';
+        const fallbackBase = fallback ? path.basename(fallback, path.extname(fallback)) : '';
+        candidate = fallbackBase || candidate;
+    }
+    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');
+
+    try {
+        await inspectZipArchiveLimits(zipPath, {
+            maxEntryCount: MAX_SKILLS_ZIP_ENTRY_COUNT,
+            maxUncompressedBytes: MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES
+        });
+
+        await extractUploadZip(zipPath, extractionRoot);
+        const discovery = collectSkillDirectoriesFromRoot(extractionRoot, MAX_SKILLS_ZIP_ENTRY_COUNT);
+        const discoveredDirs = discovery.results;
+        if (discoveredDirs.length === 0) {
+            return { error: '压缩包中未发现包含 SKILL.md 的技能目录' };
+        }
+        if (discovery.truncated) {
+            return { error: '压缩包中的技能目录数量超出导入上限' };
+        }
+
+        ensureDir(CODEX_SKILLS_DIR);
+        for (const skillDir of discoveredDirs) {
+            const normalizedName = resolveSkillNameFromImportedDirectory(skillDir, extractionRoot, fallbackName);
+            if (normalizedName.error) {
+                failed.push({
+                    name: path.basename(skillDir || ''),
+                    error: normalizedName.error
+                });
+                continue;
+            }
+            const dedupKey = normalizedName.name.toLowerCase();
+            if (dedupNames.has(dedupKey)) {
+                continue;
+            }
+            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: '目标路径非法'
+                });
+                continue;
+            }
+            if (fs.existsSync(targetPath)) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: 'Codex 中已存在同名 skill'
+                });
+                continue;
+            }
+
+            let copiedToTarget = false;
+            try {
+                const sourceRealPath = fs.realpathSync(skillDir);
+                const sourceStat = fs.statSync(sourceRealPath);
+                if (!sourceStat.isDirectory()) {
+                    failed.push({
+                        name: normalizedName.name,
+                        error: '来源 skill 无法读取'
+                    });
+                    continue;
+                }
+                const visitedRealPaths = new Set([sourceRealPath]);
+                copyDirRecursive(sourceRealPath, targetPath, {
+                    dereferenceSymlinks: true,
+                    allowedRootRealPath: sourceRealPath,
+                    visitedRealPaths
+                });
+                copiedToTarget = true;
+                imported.push({
+                    name: normalizedName.name,
+                    path: targetPath
+                });
+            } catch (e) {
+                if (!copiedToTarget && fs.existsSync(targetPath)) {
+                    try {
+                        removeDirectoryRecursive(targetPath);
+                    } catch (_) {}
+                }
+                failed.push({
+                    name: normalizedName.name,
+                    error: e && e.message ? e.message : '导入失败'
+                });
+            }
+        }
+
+        if (imported.length === 0 && failed.length > 0) {
+            return {
+                error: failed[0].error || '导入失败',
+                imported,
+                failed,
+                root: CODEX_SKILLS_DIR
+            };
+        }
+
+        return {
+            success: failed.length === 0,
+            imported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } catch (e) {
+        return {
+            error: `导入失败：${e && e.message ? e.message : '未知错误'}`
+        };
+    } finally {
+        if (tempDir) {
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            } catch (_) {}
+        } else if (fs.existsSync(extractionRoot)) {
+            try {
+                fs.rmSync(extractionRoot, { recursive: true, force: true });
+            } catch (_) {}
+        }
+    }
+}
+
+async function importCodexSkillsFromZip(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');
+    if (upload.error) {
+        return { error: upload.error };
+    }
+    return importCodexSkillsFromZipFile(upload.zipPath, {
+        tempDir: upload.tempDir,
+        fallbackName: payload.fileName || ''
+    });
 }
 
-async function fetchModelsFromBaseUrlCore(baseUrl, apiKey) {
-    const candidates = buildModelsCandidates(baseUrl);
-    if (candidates.length === 0) return { error: 'Provider missing URL' };
+async function exportCodexSkills(params = {}) {
+    const rawNames = Array.isArray(params.names) ? params.names : [];
+    const uniqueNames = Array.from(new Set(rawNames
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter(Boolean)));
+    if (uniqueNames.length === 0) {
+        return { error: '请先选择要导出的 skill' };
+    }
 
-    let lastError = '';
-    for (const modelsUrl of candidates) {
-        let parsed;
-        try {
-            parsed = new URL(modelsUrl);
-        } catch (e) {
-            lastError = 'Invalid URL';
-            continue;
-        }
+    const exported = [];
+    const failed = [];
+    const stagingTempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-skills-export-'));
+    const stagingRoot = path.join(stagingTempDir, 'skills');
+    ensureDir(stagingRoot);
 
-        const transport = parsed.protocol === 'https:' ? https : http;
-        const agent = parsed.protocol === 'https:' ? HTTPS_KEEP_ALIVE_AGENT : HTTP_KEEP_ALIVE_AGENT;
-        const headers = {
-            'User-Agent': 'codexmate-models',
-            'Accept': 'application/json'
-        };
-        if (apiKey) {
-            headers['Authorization'] = `Bearer ${apiKey}`;
-            headers['x-api-key'] = apiKey;
-        }
+    try {
+        for (const rawName of uniqueNames) {
+            const normalizedName = normalizeCodexSkillName(rawName);
+            if (normalizedName.error) {
+                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);
+            if (sourceRelative.startsWith('..') || path.isAbsolute(sourceRelative)) {
+                failed.push({ name: normalizedName.name, error: '来源路径非法' });
+                continue;
+            }
+            if (!fs.existsSync(sourcePath)) {
+                failed.push({ name: normalizedName.name, error: 'skill 不存在' });
+                continue;
+            }
 
-        const result = await new Promise((innerResolve) => {
-            let settled = false;
-            const finish = (payload) => {
-                if (settled) return;
-                settled = true;
-                innerResolve(payload);
-            };
-            const req = transport.request(parsed, { method: 'GET', headers, agent }, (res) => {
-                const status = res.statusCode || 0;
-                const contentType = String(res.headers['content-type'] || '').toLowerCase();
-                if (status === 404 || status === 405 || status === 501) {
-                    res.resume();
-                    return finish({ unavailable: true });
+            try {
+                const lstat = fs.lstatSync(sourcePath);
+                if (!lstat.isDirectory() && !lstat.isSymbolicLink()) {
+                    failed.push({ name: normalizedName.name, error: '来源不是技能目录' });
+                    continue;
                 }
-                let body = '';
-                let receivedBytes = 0;
-                res.on('data', chunk => {
-                    receivedBytes += chunk.length || 0;
-                    if (receivedBytes > MODELS_RESPONSE_MAX_BYTES) {
-                        res.destroy();
-                        return finish({ unavailable: true });
-                    }
-                    body += chunk;
+                const sourceDirForCopy = lstat.isSymbolicLink() ? fs.realpathSync(sourcePath) : sourcePath;
+                const sourceStat = fs.statSync(sourceDirForCopy);
+                if (!sourceStat.isDirectory()) {
+                    failed.push({ name: normalizedName.name, error: '来源 skill 无法读取' });
+                    continue;
+                }
+                const targetPath = path.join(stagingRoot, normalizedName.name);
+                const visitedRealPaths = new Set([sourceDirForCopy]);
+                copyDirRecursive(sourceDirForCopy, targetPath, {
+                    dereferenceSymlinks: true,
+                    allowedRootRealPath: sourceDirForCopy,
+                    visitedRealPaths
                 });
-                res.on('end', () => {
-                    if (settled) return;
-                    if (status >= 400) {
-                        return finish({ error: `Request failed: ${status}` });
-                    }
-                    if (contentType && !contentType.includes('application/json')) {
-                        return finish({ unavailable: true });
-                    }
-                    try {
-                        const payload = JSON.parse(body || '{}');
-                        if (!hasModelsListPayload(payload)) {
-                            return finish({ unavailable: true });
-                        }
-                        const models = extractModelNames(payload);
-                        return finish({ models });
-                    } catch (e) {
-                        return finish({ unavailable: true });
-                    }
+                exported.push({
+                    name: normalizedName.name,
+                    path: sourcePath
                 });
-            });
-
-            req.setTimeout(SPEED_TEST_TIMEOUT_MS, () => {
-                req.destroy(new Error('timeout'));
-            });
-            req.on('error', (err) => {
-                finish({ error: err.message || 'Request failed' });
-            });
-            req.end();
-        });
+            } catch (e) {
+                failed.push({
+                    name: normalizedName.name,
+                    error: e && e.message ? e.message : '导出失败'
+                });
+            }
+        }
 
-        if (result && Array.isArray(result.models)) {
-            return { models: result.models };
+        if (exported.length === 0) {
+            return {
+                error: failed[0] && failed[0].error ? failed[0].error : '无可导出的 skill',
+                exported,
+                failed,
+                root: CODEX_SKILLS_DIR
+            };
         }
-        if (result && result.error) {
-            lastError = result.error;
-            continue;
+
+        const randomToken = crypto.randomBytes(12).toString('hex');
+        const zipFileName = `codex-skills-${randomToken}.zip`;
+        const zipFilePath = path.join(os.tmpdir(), zipFileName);
+        if (fs.existsSync(zipFilePath)) {
+            try {
+                fs.unlinkSync(zipFilePath);
+            } catch (_) {}
         }
-    }
+        await zipLib.archiveFolder(stagingRoot, zipFilePath);
+        const artifact = registerDownloadArtifact(zipFilePath, {
+            fileName: zipFileName,
+            deleteAfterDownload: true
+        });
 
-    if (lastError) {
-        return { error: lastError };
+        return {
+            success: failed.length === 0,
+            fileName: zipFileName,
+            downloadPath: artifact.downloadPath,
+            exported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } catch (e) {
+        return {
+            error: `导出失败：${e && e.message ? e.message : '未知错误'}`,
+            exported,
+            failed,
+            root: CODEX_SKILLS_DIR
+        };
+    } finally {
+        try {
+            fs.rmSync(stagingTempDir, { recursive: true, force: true });
+        } catch (_) {}
     }
-    return { unlimited: true };
 }
 
-async function fetchProviderModels(providerName, overrides = {}) {
-    const { config } = readConfigOrVirtualDefault();
-    const targetProvider = providerName || config.model_provider || '';
-    if (!targetProvider) return { error: '未设置当前提供商' };
+function removeDirectoryRecursive(targetPath) {
+    if (typeof fs.rmSync === 'function') {
+        fs.rmSync(targetPath, { recursive: true, force: false });
+        return;
+    }
+    fs.rmdirSync(targetPath, { recursive: true });
+}
 
-    const providers = config.model_providers || {};
-    const provider = providers[targetProvider];
-    if (!provider) return { error: `提供商不存在: ${targetProvider}` };
+function deleteCodexSkills(params = {}) {
+    const rawList = Array.isArray(params.names) ? params.names : [];
+    const uniqueNames = Array.from(new Set(rawList
+        .map((item) => (typeof item === 'string' ? item.trim() : ''))
+        .filter(Boolean)));
+    if (!uniqueNames.length) {
+        return { error: '请先选择要删除的 skill' };
+    }
 
-    const baseUrl = overrides.baseUrl || provider.base_url || '';
-    const apiKey = overrides.apiKey ?? provider.preferred_auth_method ?? '';
-    const res = await fetchModelsFromBaseUrl(baseUrl, apiKey);
-    if (res.unlimited) return { models: [], provider: targetProvider, unlimited: true };
-    if (res.error) return { error: res.error };
-    return { models: res.models || [], provider: targetProvider, unlimited: false };
-}
+    const deleted = [];
+    const failed = [];
+    for (const rawName of uniqueNames) {
+        const normalized = normalizeCodexSkillName(rawName);
+        if (normalized.error) {
+            failed.push({ name: rawName, error: normalized.error });
+            continue;
+        }
 
-function resolveAgentsFilePath(params = {}) {
-    const baseDir = typeof params.baseDir === 'string' && params.baseDir.trim()
-        ? params.baseDir.trim()
-        : CONFIG_DIR;
-    return path.join(baseDir, AGENTS_FILE_NAME);
-}
+        const skillPath = path.join(CODEX_SKILLS_DIR, normalized.name);
+        const relativePath = path.relative(CODEX_SKILLS_DIR, skillPath);
+        if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+            failed.push({ name: normalized.name, error: '技能路径非法' });
+            continue;
+        }
+        if (!fs.existsSync(skillPath)) {
+            failed.push({ name: normalized.name, error: 'skill 不存在' });
+            continue;
+        }
 
-function validateAgentsBaseDir(filePath) {
-    const dirPath = path.dirname(filePath);
-    try {
-        const stat = fs.statSync(dirPath);
-        if (!stat.isDirectory()) {
-            return { error: `目标不是目录: ${dirPath}` };
+        try {
+            const stat = fs.lstatSync(skillPath);
+            if (!stat.isDirectory() && !stat.isSymbolicLink()) {
+                failed.push({ name: normalized.name, error: '仅支持删除技能目录' });
+                continue;
+            }
+            removeDirectoryRecursive(skillPath);
+            deleted.push(normalized.name);
+        } catch (e) {
+            failed.push({
+                name: normalized.name,
+                error: e && e.message ? e.message : '删除失败'
+            });
         }
-    } catch (e) {
-        return { error: `目标目录不存在: ${dirPath}` };
     }
-    return { ok: true, dirPath };
+
+    return {
+        success: failed.length === 0,
+        deleted,
+        failed,
+        root: CODEX_SKILLS_DIR
+    };
 }
 
 function readAgentsFile(params = {}) {
@@ -1307,11 +2718,28 @@ async function buildConfigHealthReport(params = {}) {
     const config = status.config || {};
 
     if (status.isVirtual) {
+        const parseFailed = status.errorType === 'parse';
+        const readFailed = status.errorType === 'read';
         issues.push({
-            code: 'config-missing',
-            message: status.reason || '未检测到 config.toml',
-            suggestion: '在模板编辑器中确认应用配置，生成可用的 config.toml'
+            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() : '';
@@ -1498,13 +2926,26 @@ function readConfigOrVirtualDefault() {
             return {
                 config: readConfig(),
                 isVirtual: false,
-                reason: ''
+                reason: '',
+                detail: '',
+                errorType: ''
             };
         } catch (e) {
+            const errorType = typeof e.configErrorType === 'string' && e.configErrorType.trim()
+                ? e.configErrorType.trim()
+                : 'read';
+            const publicReason = typeof e.configPublicReason === 'string' && e.configPublicReason.trim()
+                ? e.configPublicReason.trim()
+                : (errorType === 'parse' ? 'config.toml 解析失败' : '读取 config.toml 失败');
+            const detail = typeof e.configDetail === 'string' && e.configDetail.trim()
+                ? e.configDetail.trim()
+                : (e && e.message ? e.message : publicReason);
             return {
-                config: buildVirtualDefaultConfig(),
+                config: errorType === 'missing' ? buildVirtualDefaultConfig() : {},
                 isVirtual: true,
-                reason: e.message || '配置文件无效，已回退到默认模板'
+                reason: publicReason,
+                detail,
+                errorType
             };
         }
     }
@@ -1512,10 +2953,31 @@ function readConfigOrVirtualDefault() {
     return {
         config: buildVirtualDefaultConfig(),
         isVirtual: true,
-        reason: `配置文件不存在: ${CONFIG_FILE}`
+        reason: '未检测到 config.toml',
+        detail: `配置文件不存在: ${CONFIG_FILE}`,
+        errorType: 'missing'
     };
 }
 
+function hasConfigLoadError(result) {
+    return !!(result
+        && result.isVirtual
+        && (result.errorType === 'parse' || result.errorType === 'read'));
+}
+
+function printConfigLoadErrorAndMarkExit(result) {
+    const isReadError = result && result.errorType === 'read';
+    const detail = result && typeof result.detail === 'string' && result.detail.trim()
+        ? result.detail.trim()
+        : (isReadError ? '读取配置文件失败' : '配置文件解析失败');
+    console.error(`\n错误: ${isReadError ? '读取 config.toml 失败' : '配置文件解析失败'}`);
+    console.error(`  详情: ${detail}`);
+    console.error(`  路径: ${CONFIG_FILE}`);
+    console.error(`  建议: ${isReadError ? '检查文件权限后重试' : '修复 config.toml 语法后重试'}`);
+    console.error();
+    process.exitCode = 1;
+}
+
 function normalizeTopLevelConfigWithTemplate(template, selectedProvider, selectedModel) {
     let content = typeof template === 'string' ? template : '';
     if (!content.trim()) {
@@ -1656,6 +3118,9 @@ function addProviderToConfig(params = {}) {
 
     if (!name) return { error: '名称不能为空' };
     if (!url) return { error: 'URL 不能为空' };
+    if (!isValidProviderName(name)) {
+        return { error: '名称仅支持字母/数字/._-' };
+    }
     if (isReservedProviderNameForCreation(name)) {
         return { error: 'local provider 为系统保留名称，不可新增' };
     }
@@ -1687,24 +3152,20 @@ function addProviderToConfig(params = {}) {
         return { error: `config.toml 解析失败: ${e.message}` };
     }
 
-    if (!parsed.model_providers || typeof parsed.model_providers !== 'object') {
-        parsed.model_providers = {};
-    }
-
-    if (parsed.model_providers[name]) {
+    const providerHeaderSegmentKeySet = collectModelProviderHeaderSegmentKeySet(content);
+    const normalizedProviders = isPlainObject(parsed.model_providers)
+        ? normalizeLegacyModelProviders(parsed.model_providers, providerHeaderSegmentKeySet)
+        : {};
+    if (normalizedProviders && normalizedProviders[name]) {
         return { error: '提供商已存在' };
     }
 
-    const escapeTomlString = (value) => String(value || '')
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"');
-
     const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
-    const safeName = escapeTomlString(name);
-    const safeUrl = escapeTomlString(url);
-    const safeKey = escapeTomlString(key);
+    const safeName = escapeTomlBasicString(name);
+    const safeUrl = escapeTomlBasicString(url);
+    const safeKey = escapeTomlBasicString(key);
     const block = [
-        `[model_providers.${safeName}]`,
+        buildModelProviderTableHeader(name),
         `name = "${safeName}"`,
         `base_url = "${safeUrl}"`,
         `wire_api = "responses"`,
@@ -1804,8 +3265,36 @@ function performProviderDeletion(name, options = {}) {
     const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
     const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
     const hasBom = content.charCodeAt(0) === 0xFEFF;
-    const safeName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const sectionRegex = new RegExp(`\\[\\s*model_providers\\s*\\.\\s*(?:"${safeName}"|'${safeName}'|${safeName})\\s*\\]`);
+    const providerConfig = config.model_providers[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(name || '').split('.').filter((item) => item));
+        }
+        return variants;
+    })();
 
     const remainingProviders = Object.keys(config.model_providers || {}).filter(item => item !== name);
     if (remainingProviders.length === 0) {
@@ -1844,17 +3333,25 @@ function performProviderDeletion(name, options = {}) {
     };
 
     let updatedContent = null;
-    const match = content.match(sectionRegex);
-    if (match) {
-        const startIdx = match.index;
-        const rest = content.slice(startIdx + match[0].length);
-        const nextIdx = rest.indexOf('[');
-        const endIdx = nextIdx === -1 ? content.length : (startIdx + match[0].length + nextIdx);
-
-        const removedContent = (content.slice(0, startIdx) + content.slice(endIdx))
-            .replace(/\n{3,}/g, lineEnding + lineEnding);
-
-        updatedContent = removedContent;
+    const combinedRanges = [];
+    for (const segments of providerSegmentVariants) {
+        combinedRanges.push(...findProviderSectionRanges(content, name, segments));
+        combinedRanges.push(...findProviderDescendantSectionRanges(content, segments));
+    }
+    if (combinedRanges.length === 0) {
+        combinedRanges.push(...findProviderSectionRanges(content, 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) {
@@ -4857,7 +6354,12 @@ async function cmdSetup() {
 
 // 显示当前状态
 function cmdStatus() {
-    const { config, isVirtual } = readConfigOrVirtualDefault();
+    const configResult = readConfigOrVirtualDefault();
+    if (hasConfigLoadError(configResult)) {
+        printConfigLoadErrorAndMarkExit(configResult);
+        return;
+    }
+    const { config, isVirtual } = configResult;
     const current = config.model_provider || '未设置';
     const currentModel = config.model || '未设置';
 
@@ -4873,7 +6375,12 @@ function cmdStatus() {
 
 // 列出所有提供商
 function cmdList() {
-    const { config, isVirtual } = readConfigOrVirtualDefault();
+    const configResult = readConfigOrVirtualDefault();
+    if (hasConfigLoadError(configResult)) {
+        printConfigLoadErrorAndMarkExit(configResult);
+        return;
+    }
+    const { config, isVirtual } = configResult;
     const providers = config.model_providers || {};
     const current = config.model_provider;
 
@@ -5028,6 +6535,10 @@ function cmdAdd(name, baseUrl, apiKey, silent = false) {
         }
         throw new Error('名称和URL必填');
     }
+    if (!isValidProviderName(providerName)) {
+        if (!silent) console.error('错误: 名称仅支持字母/数字/._-');
+        throw new Error('名称仅支持字母/数字/._-');
+    }
     if (isReservedProviderNameForCreation(providerName)) {
         if (!silent) console.error('错误: local provider 为系统保留名称，不可新增');
         throw new Error('local provider 为系统保留名称，不可新增');
@@ -5039,13 +6550,16 @@ function cmdAdd(name, baseUrl, apiKey, silent = false) {
         throw new Error('提供商已存在');
     }
 
+    const safeName = escapeTomlBasicString(providerName);
+    const safeBaseUrl = escapeTomlBasicString(providerBaseUrl);
+    const safeApiKey = escapeTomlBasicString(apiKey || '');
     const newBlock = `
-[model_providers.${providerName}]
-name = "${providerName}"
-base_url = "${providerBaseUrl}"
+${buildModelProviderTableHeader(providerName)}
+name = "${safeName}"
+base_url = "${safeBaseUrl}"
 wire_api = "responses"
 requires_openai_auth = false
-preferred_auth_method = "${apiKey || ''}"
+preferred_auth_method = "${safeApiKey}"
 request_max_retries = 4
 stream_max_retries = 10
 stream_idle_timeout_ms = 300000
@@ -5105,42 +6619,156 @@ function cmdUpdate(name, baseUrl, apiKey, silent = false, options = {}) {
     }
 
     const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
-    const safeName = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const sectionRegex = new RegExp(`\\[\\s*model_providers\\s*\\.\\s*${safeName}\\s*\\]`);
-    const match = content.match(sectionRegex);
-    if (!match) {
+    const providerConfig = config.model_providers[name];
+    const providerSegments = providerConfig && Array.isArray(providerConfig.__codexmate_legacy_segments)
+        ? providerConfig.__codexmate_legacy_segments
+        : null;
+    const ranges = findProviderSectionRanges(content, name, providerSegments);
+    if (ranges.length === 0) {
         if (!silent) console.error('错误: 无法找到提供商配置块');
         throw new Error('无法找到提供商配置块');
     }
 
-    const startIdx = match.index;
-    const rest = content.slice(startIdx + match[0].length);
-    const nextIdx = rest.indexOf('[');
-    const endIdx = nextIdx === -1 ? content.length : (startIdx + match[0].length + nextIdx);
-
-    // 提取该提供商的配置块
-    const providerBlock = content.slice(startIdx, endIdx);
+    const replaceTomlStringField = (block, fieldName, rawValue) => {
+        const safeValue = escapeTomlBasicString(rawValue);
+        const escapedFieldName = escapeRegex(fieldName);
+        const multilineRanges = collectTomlMultilineStringRanges(block);
+        const tripleStartRegex = new RegExp(`^(\\s*${escapedFieldName}\\s*=\\s*)(\"\"\"|''')`, 'mg');
+        let tripleStartMatch = null;
+        let tripleCandidate;
+        while ((tripleCandidate = tripleStartRegex.exec(block)) !== null) {
+            if (isIndexInRanges(tripleCandidate.index, multilineRanges)) {
+                continue;
+            }
+            tripleStartMatch = tripleCandidate;
+            break;
+        }
+        if (tripleStartMatch) {
+            const prefixStart = tripleStartMatch.index;
+            const prefixEnd = prefixStart + tripleStartMatch[1].length;
+            const tripleQuote = tripleStartMatch[2];
+            const valueStart = prefixEnd + tripleQuote.length;
+            const quoteChar = tripleQuote[0];
+            let valueEnd = -1;
+            let closingRunLength = 0;
+            for (let i = valueStart; i < block.length; i++) {
+                if (block[i] !== quoteChar) continue;
+                let runEnd = i + 1;
+                while (runEnd < block.length && block[runEnd] === quoteChar) {
+                    runEnd++;
+                }
+                const runLength = runEnd - i;
+                if (runLength < tripleQuote.length) {
+                    i = runEnd - 1;
+                    continue;
+                }
+                if (tripleQuote === '"""') {
+                    let slashCount = 0;
+                    for (let j = i - 1; j >= valueStart && block[j] === '\\'; j--) {
+                        slashCount++;
+                    }
+                    if (slashCount % 2 !== 0) {
+                        continue;
+                    }
+                }
+                valueEnd = i;
+                closingRunLength = runLength;
+                break;
+            }
+            if (valueEnd === -1) {
+                throw new Error(`${fieldName} 使用了未闭合的多行 TOML 字符串，无法安全更新`);
+            }
+            const lineEndIndex = block.indexOf('\n', valueEnd + closingRunLength);
+            let tailEnd = lineEndIndex === -1 ? block.length : lineEndIndex;
+            if (lineEndIndex > 0 && block[lineEndIndex - 1] === '\r') {
+                tailEnd = lineEndIndex - 1;
+            }
+            const tail = block.slice(valueEnd + closingRunLength, tailEnd);
+            const tailMatch = tail.match(/^(\s+#.*)?\s*$/);
+            if (!tailMatch) {
+                throw new Error(`${fieldName} 多行字符串后的语法不受支持，无法安全更新`);
+            }
+            const commentSuffix = tailMatch[1] || '';
+            const replacementLine = `${block.slice(prefixStart, prefixEnd)}"${safeValue}"${commentSuffix}`;
+            return block.slice(0, prefixStart) + replacementLine + block.slice(tailEnd);
+        }
 
-    // 替换 base_url
-    let updatedBlock = providerBlock;
-    if (baseUrl) {
-        updatedBlock = updatedBlock.replace(
-            /^(base_url\s*=\s*)(["']).*?\2/m,
-            `$1$2${baseUrl}$2`
+        const withCommentRegex = new RegExp(
+            `^(\\s*${escapedFieldName}\\s*=\\s*)(?:"(?:\\\\.|[^"\\\\])*"|'[^'\\n]*')(\\s+#.*)?$`,
+            'mg'
         );
-    }
-
-    // 替换 preferred_auth_method (API Key)
-    if (apiKey !== undefined) {
-        updatedBlock = updatedBlock.replace(
-            /^(preferred_auth_method\s*=\s*)(["']).*?\2/m,
-            `$1$2${apiKey}$2`
+        let replaced = false;
+        let next = block.replace(
+            withCommentRegex,
+            (full, prefix, suffix = '', offset) => {
+                if (replaced || isIndexInRanges(offset, multilineRanges)) {
+                    return full;
+                }
+                replaced = true;
+                return `${prefix}"${safeValue}"${suffix}`;
+            }
         );
+        if (!replaced) {
+            const fallbackRegex = new RegExp(`^(\\s*${escapedFieldName}\\s*=\\s*)(.*?)(\\s+#.*)?$`, 'mg');
+            let fallbackReplaced = false;
+            const multilineRangesForNext = collectTomlMultilineStringRanges(next);
+            let fallbackMatch;
+            let fallbackCandidate;
+            while ((fallbackCandidate = fallbackRegex.exec(next)) !== null) {
+                if (isIndexInRanges(fallbackCandidate.index, multilineRangesForNext)) {
+                    continue;
+                }
+                fallbackMatch = fallbackCandidate;
+                break;
+            }
+            if (fallbackMatch) {
+                const existingValue = String(fallbackMatch[2] || '').trim();
+                const looksLikeMultilineArray = existingValue.startsWith('[') && !existingValue.endsWith(']');
+                const looksLikeMultilineInlineTable = existingValue.startsWith('{') && !existingValue.endsWith('}');
+                if (looksLikeMultilineArray || looksLikeMultilineInlineTable) {
+                    throw new Error(`${fieldName} 当前值是多行 TOML 结构，无法安全更新`);
+                }
+                const prefix = fallbackMatch[1];
+                const suffix = fallbackMatch[3] || '';
+                const replacement = `${prefix}"${safeValue}"${suffix}`;
+                next = `${next.slice(0, fallbackMatch.index)}${replacement}${next.slice(fallbackMatch.index + fallbackMatch[0].length)}`;
+                fallbackReplaced = true;
+            }
+            if (!fallbackReplaced) {
+                const keyIndentMatch = block.match(/^(\s*)[A-Za-z0-9_.-]+\s*=/m);
+                const indent = keyIndentMatch ? keyIndentMatch[1] : '';
+                const lineEnding = block.includes('\r\n') ? '\r\n' : '\n';
+                const tailMatch = block.match(/(\s*)$/);
+                const tail = tailMatch ? tailMatch[1] : '';
+                const body = block.slice(0, block.length - tail.length);
+                const separator = body.endsWith('\n') || body.endsWith('\r') ? '' : lineEnding;
+                next = `${body}${separator}${indent}${fieldName} = "${safeValue}"${tail}`;
+            }
+        }
+        return next;
+    };
+
+    let newContent = content;
+    const sorted = ranges.sort((a, b) => b.start - a.start);
+    for (const range of sorted) {
+        const providerBlock = newContent.slice(range.start, range.end);
+        let updatedBlock = providerBlock;
+        if (baseUrl) {
+            updatedBlock = replaceTomlStringField(updatedBlock, 'base_url', baseUrl);
+        }
+        if (apiKey !== undefined) {
+            updatedBlock = replaceTomlStringField(updatedBlock, 'preferred_auth_method', apiKey);
+        }
+        newContent = newContent.slice(0, range.start) + updatedBlock + newContent.slice(range.end);
     }
 
-    // 组合新的内容
-    const newContent = content.slice(0, startIdx) + updatedBlock + content.slice(endIdx);
-    writeConfig(newContent.trim());
+    const finalContent = newContent.trim();
+    try {
+        toml.parse(finalContent);
+    } catch (e) {
+        throw new Error(`更新后的 config.toml 无效: ${e.message}`);
+    }
+    writeConfig(finalContent);
 
     // 如果更新了 API Key 且该提供商是当前激活的，同步更新 auth.json
     const currentProvider = config.model_provider;
@@ -5297,12 +6925,76 @@ function readClaudeSettingsInfo() {
         : {};
 
     return {
-        exists: !!readResult.exists,
-        targetPath: CLAUDE_SETTINGS_FILE,
-        apiKey: typeof env.ANTHROPIC_API_KEY === 'string' ? env.ANTHROPIC_API_KEY : '',
-        baseUrl: typeof env.ANTHROPIC_BASE_URL === 'string' ? env.ANTHROPIC_BASE_URL : '',
-        model: typeof env.ANTHROPIC_MODEL === 'string' ? env.ANTHROPIC_MODEL : '',
-        env
+        exists: !!readResult.exists,
+        targetPath: CLAUDE_SETTINGS_FILE,
+        apiKey: typeof env.ANTHROPIC_API_KEY === 'string' ? env.ANTHROPIC_API_KEY : '',
+        baseUrl: typeof env.ANTHROPIC_BASE_URL === 'string' ? env.ANTHROPIC_BASE_URL : '',
+        model: typeof env.ANTHROPIC_MODEL === 'string' ? env.ANTHROPIC_MODEL : '',
+        env
+    };
+}
+
+function registerDownloadArtifact(filePath, options = {}) {
+    const token = crypto.randomBytes(16).toString('hex');
+    const fileName = typeof options.fileName === 'string' && options.fileName.trim()
+        ? options.fileName.trim()
+        : path.basename(filePath || '');
+    const ttlMs = Number.isFinite(options.ttlMs) && options.ttlMs > 0
+        ? Math.floor(options.ttlMs)
+        : DOWNLOAD_ARTIFACT_TTL_MS;
+    const expiresAt = Date.now() + ttlMs;
+    const deleteAfterDownload = options.deleteAfterDownload !== false;
+
+    g_downloadArtifacts.set(token, {
+        filePath,
+        fileName,
+        deleteAfterDownload,
+        expiresAt
+    });
+
+    setTimeout(() => {
+        const artifact = g_downloadArtifacts.get(token);
+        if (!artifact) return;
+        if (Date.now() < artifact.expiresAt) return;
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+    }, ttlMs + 2000);
+
+    return {
+        token,
+        fileName,
+        downloadPath: `/download/${encodeURIComponent(token)}`
+    };
+}
+
+function resolveDownloadArtifact(tokenOrFileName, options = {}) {
+    if (!tokenOrFileName) return null;
+    const token = typeof tokenOrFileName === 'string' ? tokenOrFileName.trim() : '';
+    if (!token) return null;
+
+    const artifact = g_downloadArtifacts.get(token);
+    if (!artifact) {
+        return null;
+    }
+    if (Date.now() > artifact.expiresAt) {
+        g_downloadArtifacts.delete(token);
+        if (artifact.deleteAfterDownload && artifact.filePath && fs.existsSync(artifact.filePath)) {
+            try {
+                fs.unlinkSync(artifact.filePath);
+            } catch (_) {}
+        }
+        return null;
+    }
+    if (options && options.consume === true) {
+        g_downloadArtifacts.delete(token);
+    }
+    return {
+        token,
+        ...artifact
     };
 }
 
@@ -5368,23 +7060,206 @@ async function prepareCodexDirDownload() {
     }
 }
 
-function copyDirRecursive(srcDir, destDir) {
+function copyDirRecursive(srcDir, destDir, options = {}) {
+    const dereferenceSymlinks = !!(options && options.dereferenceSymlinks);
+    const allowedRootRealPath = (options && typeof options.allowedRootRealPath === 'string')
+        ? options.allowedRootRealPath
+        : '';
+    const visitedRealPaths = options && options.visitedRealPaths instanceof Set
+        ? options.visitedRealPaths
+        : new Set();
+    const childOptions = {
+        ...options,
+        dereferenceSymlinks,
+        allowedRootRealPath,
+        visitedRealPaths
+    };
     ensureDir(destDir);
     const entries = fs.readdirSync(srcDir, { withFileTypes: true });
     for (const entry of entries) {
         const srcPath = path.join(srcDir, entry.name);
         const destPath = path.join(destDir, entry.name);
         if (entry.isDirectory()) {
-            copyDirRecursive(srcPath, destPath);
+            if (!dereferenceSymlinks) {
+                copyDirRecursive(srcPath, destPath, childOptions);
+                continue;
+            }
+            const realPath = fs.realpathSync(srcPath);
+            if (allowedRootRealPath && !isPathInside(realPath, allowedRootRealPath)) {
+                throw new Error(`symlink escapes skill root: ${srcPath}`);
+            }
+            if (visitedRealPaths.has(realPath)) {
+                continue;
+            }
+            visitedRealPaths.add(realPath);
+            try {
+                copyDirRecursive(srcPath, destPath, childOptions);
+            } finally {
+                visitedRealPaths.delete(realPath);
+            }
         } else if (entry.isSymbolicLink()) {
-            const target = fs.readlinkSync(srcPath);
-            fs.symlinkSync(target, destPath);
+            if (dereferenceSymlinks) {
+                const realPath = fs.realpathSync(srcPath);
+                if (allowedRootRealPath && !isPathInside(realPath, allowedRootRealPath)) {
+                    throw new Error(`symlink escapes skill root: ${srcPath}`);
+                }
+                const realStat = fs.statSync(realPath);
+                if (realStat.isDirectory()) {
+                    if (visitedRealPaths.has(realPath)) {
+                        continue;
+                    }
+                    visitedRealPaths.add(realPath);
+                    try {
+                        copyDirRecursive(realPath, destPath, childOptions);
+                    } finally {
+                        visitedRealPaths.delete(realPath);
+                    }
+                } else {
+                    fs.copyFileSync(realPath, destPath);
+                }
+            } else {
+                const target = fs.readlinkSync(srcPath);
+                fs.symlinkSync(target, destPath);
+            }
         } else {
             fs.copyFileSync(srcPath, destPath);
         }
     }
 }
 
+function inspectZipArchiveLimits(zipPath, options = {}) {
+    const maxEntryCount = Number.isFinite(options.maxEntryCount) && options.maxEntryCount > 0
+        ? Math.floor(options.maxEntryCount)
+        : MAX_SKILLS_ZIP_ENTRY_COUNT;
+    const maxUncompressedBytes = Number.isFinite(options.maxUncompressedBytes) && options.maxUncompressedBytes > 0
+        ? Math.floor(options.maxUncompressedBytes)
+        : MAX_SKILLS_ZIP_UNCOMPRESSED_BYTES;
+
+    return new Promise((resolve, reject) => {
+        yauzl.open(zipPath, { lazyEntries: true, autoClose: true }, (openErr, zipFile) => {
+            if (openErr) {
+                reject(openErr);
+                return;
+            }
+            if (!zipFile) {
+                reject(new Error('无法读取 ZIP 文件'));
+                return;
+            }
+            let entryCount = 0;
+            let totalUncompressedBytes = 0;
+            let settled = false;
+            const finish = (err, data) => {
+                if (settled) return;
+                settled = true;
+                try {
+                    zipFile.close();
+                } catch (_) {}
+                if (err) {
+                    reject(err);
+                } else {
+                    resolve(data);
+                }
+            };
+
+            zipFile.on('entry', (entry) => {
+                if (settled) return;
+                entryCount += 1;
+                const entrySize = Number.isFinite(entry.uncompressedSize) ? entry.uncompressedSize : 0;
+                totalUncompressedBytes += entrySize;
+                if (entryCount > maxEntryCount) {
+                    finish(new Error(`压缩包条目过多（>${maxEntryCount}）`));
+                    return;
+                }
+                if (totalUncompressedBytes > maxUncompressedBytes) {
+                    finish(new Error(`压缩包解压总大小超限（>${Math.floor(maxUncompressedBytes / 1024 / 1024)}MB）`));
+                    return;
+                }
+                zipFile.readEntry();
+            });
+
+            zipFile.on('end', () => {
+                finish(null, { entryCount, totalUncompressedBytes });
+            });
+
+            zipFile.on('error', (zipErr) => {
+                finish(zipErr);
+            });
+
+            zipFile.readEntry();
+        });
+    });
+}
+
+function writeUploadZipStream(req, prefix, originalName = '', maxSize = MAX_SKILLS_ZIP_UPLOAD_SIZE) {
+    return new Promise((resolve, reject) => {
+        const lengthHeader = parseInt(req.headers['content-length'] || '0', 10);
+        if (Number.isFinite(lengthHeader) && lengthHeader > maxSize) {
+            reject(new Error(`备份文件过大（>${Math.floor(maxSize / 1024 / 1024)}MB）`));
+            return;
+        }
+
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), `${prefix}-`));
+        const rawName = originalName && typeof originalName === 'string' ? originalName : `${prefix}.zip`;
+        const fileName = path.basename(rawName);
+        const zipPath = path.join(tempDir, fileName.toLowerCase().endsWith('.zip') ? fileName : `${fileName}.zip`);
+        const stream = fs.createWriteStream(zipPath);
+        let bytesWritten = 0;
+        let settled = false;
+        let hasContent = false;
+
+        const fail = (err) => {
+            if (settled) return;
+            settled = true;
+            try {
+                stream.destroy();
+            } catch (_) {}
+            try {
+                fs.rmSync(tempDir, { recursive: true, force: true });
+            } catch (_) {}
+            reject(err);
+        };
+
+        const done = () => {
+            if (settled) return;
+            settled = true;
+            if (!hasContent || bytesWritten <= 0) {
+                try {
+                    fs.rmSync(tempDir, { recursive: true, force: true });
+                } catch (_) {}
+                reject(new Error('备份文件为空'));
+                return;
+            }
+            resolve({ tempDir, zipPath });
+        };
+
+        req.on('error', (err) => fail(err));
+        req.on('aborted', () => fail(new Error('上传已中断')));
+        req.on('close', () => {
+            if (!settled && !req.complete) {
+                fail(new Error('上传已中断'));
+            }
+        });
+        stream.on('error', (err) => fail(err));
+        req.on('data', (chunk) => {
+            if (settled) return;
+            hasContent = true;
+            bytesWritten += chunk.length;
+            if (bytesWritten > maxSize) {
+                fail(new Error(`备份文件过大（>${Math.floor(maxSize / 1024 / 1024)}MB）`));
+                try {
+                    req.destroy();
+                } catch (_) {}
+                return;
+            }
+            stream.write(chunk);
+        });
+        req.on('end', () => {
+            if (settled) return;
+            stream.end(() => done());
+        });
+    });
+}
+
 function writeUploadZip(base64, prefix, originalName = '') {
     let buffer;
     try {
@@ -6080,7 +7955,7 @@ async function cmdExportSession(args = []) {
 }
 
 function parseStartOptions(args = []) {
-    const options = { host: '' };
+    const options = { host: '', noBrowser: false };
     if (!Array.isArray(args)) {
         return options;
     }
@@ -6088,6 +7963,10 @@ function parseStartOptions(args = []) {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (!arg) continue;
+        if (arg === '--no-browser') {
+            options.noBrowser = true;
+            continue;
+        }
         if (arg.startsWith('--host=')) {
             options.host = arg.slice('--host='.length);
             continue;
@@ -6160,11 +8039,125 @@ function watchPathsForRestart(targets, onChange) {
     };
 }
 
+function writeJsonResponse(res, statusCode, payload) {
+    const body = JSON.stringify(payload, null, 2);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json; charset=utf-8',
+        'Content-Length': Buffer.byteLength(body, 'utf-8')
+    });
+    res.end(body, 'utf-8');
+}
+
+function streamZipDownloadResponse(res, filePath, options = {}) {
+    if (!filePath || !fs.existsSync(filePath)) {
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('File Not Found');
+        return;
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+        res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Not a File');
+        return;
+    }
+    const downloadName = typeof options.fileName === 'string' && options.fileName.trim()
+        ? options.fileName.trim()
+        : path.basename(filePath);
+    const deleteAfterDownload = !!options.deleteAfterDownload;
+    const onAfterComplete = typeof options.onAfterComplete === 'function'
+        ? options.onAfterComplete
+        : null;
+    res.writeHead(200, {
+        'Content-Type': 'application/zip',
+        'Content-Disposition': `attachment; filename="${path.basename(downloadName)}"`,
+        'Content-Length': stat.size
+    });
+
+    const stream = fs.createReadStream(filePath);
+    let finished = false;
+    const finalize = () => {
+        if (finished) return;
+        finished = true;
+        if (deleteAfterDownload && fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+            } catch (_) {}
+        }
+        if (onAfterComplete) {
+            try {
+                onAfterComplete();
+            } catch (_) {}
+        }
+    };
+    stream.on('error', () => {
+        if (!res.headersSent) {
+            res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Download Error');
+        } else {
+            try {
+                res.destroy();
+            } catch (_) {}
+        }
+        finalize();
+    });
+    res.on('finish', finalize);
+    res.on('close', finalize);
+    stream.pipe(res);
+}
+
+function resolveUploadFileNameFromRequest(req, fallbackName = 'codex-skills.zip') {
+    const rawHeader = req.headers['x-codexmate-file-name'];
+    const source = Array.isArray(rawHeader) ? rawHeader[0] : rawHeader;
+    const fallback = typeof fallbackName === 'string' && fallbackName.trim()
+        ? fallbackName.trim()
+        : 'codex-skills.zip';
+    if (!source || typeof source !== 'string') {
+        return fallback;
+    }
+    const decoded = (() => {
+        try {
+            return decodeURIComponent(source);
+        } catch (_) {
+            return source;
+        }
+    })();
+    const normalized = path.basename(decoded.trim());
+    return normalized || fallback;
+}
+
+async function handleImportCodexSkillsZipUpload(req, res) {
+    if (req.method !== 'POST') {
+        writeJsonResponse(res, 405, { error: 'Method Not Allowed' });
+        return;
+    }
+    try {
+        const fileName = resolveUploadFileNameFromRequest(req, 'codex-skills.zip');
+        const upload = await writeUploadZipStream(
+            req,
+            'codex-skills-import',
+            fileName,
+            MAX_SKILLS_ZIP_UPLOAD_SIZE
+        );
+        const result = await importCodexSkillsFromZipFile(upload.zipPath, {
+            tempDir: upload.tempDir,
+            fallbackName: fileName
+        });
+        writeJsonResponse(res, 200, result || {});
+    } catch (e) {
+        const message = e && e.message ? e.message : '上传失败';
+        writeJsonResponse(res, 400, { error: message });
+    }
+}
+
 function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser }) {
     const connections = new Set();
 
     const server = http.createServer((req, res) => {
         const requestPath = (req.url || '/').split('?')[0];
+        if (requestPath === '/api/import-codex-skills-zip') {
+            void handleImportCodexSkillsZipUpload(req, res);
+            return;
+        }
         if (requestPath === '/api') {
             let body = '';
             req.on('data', chunk => body += chunk);
@@ -6185,6 +8178,7 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                                 serviceTier,
                                 modelReasoningEffort,
                                 configReady: !statusConfigResult.isVirtual,
+                                configErrorType: statusConfigResult.errorType || '',
                                 configNotice: statusConfigResult.reason || '',
                                 initNotice: consumeInitNotice()
                             };
@@ -6199,6 +8193,8 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                             const current = listConfig.model_provider;
                             result = {
                                 configReady: !listConfigResult.isVirtual,
+                                configErrorType: listConfigResult.errorType || '',
+                                configNotice: listConfigResult.reason || '',
                                 providers: Object.entries(providers).map(([name, p]) => ({
                                     name,
                                     url: p.base_url || '',
@@ -6273,6 +8269,21 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'apply-agents-file':
                             result = applyAgentsFile(params || {});
                             break;
+                        case 'list-codex-skills':
+                            result = listCodexSkills();
+                            break;
+                        case 'delete-codex-skills':
+                            result = deleteCodexSkills(params || {});
+                            break;
+                        case 'scan-unmanaged-codex-skills':
+                            result = scanUnmanagedCodexSkills();
+                            break;
+                        case 'import-codex-skills':
+                            result = importCodexSkills(params || {});
+                            break;
+                        case 'export-codex-skills':
+                            result = await exportCodexSkills(params || {});
+                            break;
                         case 'get-openclaw-config':
                             result = readOpenclawConfigFile();
                             break;
@@ -6433,6 +8444,58 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'proxy-apply-provider':
                             result = applyBuiltinProxyProvider(params || {});
                             break;
+                        case 'workflow-list':
+                            result = listWorkflowDefinitions();
+                            break;
+                        case 'workflow-get':
+                            {
+                                const id = params && typeof params.id === 'string' ? params.id.trim() : '';
+                                if (!id) {
+                                    result = { error: 'workflow id is required' };
+                                } else {
+                                    result = getWorkflowDefinitionById(id);
+                                }
+                            }
+                            break;
+                        case 'workflow-validate':
+                            {
+                                const id = params && typeof params.id === 'string' ? params.id.trim() : '';
+                                if (!id) {
+                                    result = { ok: false, error: 'workflow id is required' };
+                                    break;
+                                }
+                                const input = params && params.input && typeof params.input === 'object' && !Array.isArray(params.input)
+                                    ? params.input
+                                    : {};
+                                result = validateWorkflowById(id, input);
+                            }
+                            break;
+                        case 'workflow-run':
+                            {
+                                const id = params && typeof params.id === 'string' ? params.id.trim() : '';
+                                if (!id) {
+                                    result = { error: 'workflow id is required' };
+                                    break;
+                                }
+                                const input = params && params.input && typeof params.input === 'object' && !Array.isArray(params.input)
+                                    ? params.input
+                                    : {};
+                                result = await runWorkflowById(id, input, {
+                                    allowWrite: !!(params && params.allowWrite),
+                                    dryRun: !!(params && params.dryRun)
+                                });
+                            }
+                            break;
+                        case 'workflow-runs':
+                            {
+                                const rawLimit = params && Number.isFinite(params.limit) ? params.limit : parseInt(params && params.limit, 10);
+                                const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.floor(rawLimit)) : 20;
+                                result = {
+                                    runs: listWorkflowRunRecords(limit),
+                                    limit
+                                };
+                            }
+                            break;
                         default:
                             result = { error: '未知操作' };
                     }
@@ -6479,32 +8542,35 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
             fs.createReadStream(filePath).pipe(res);
         } else if (requestPath.startsWith('/download/')) {
             const fileName = requestPath.slice('/download/'.length);
-            const decodedFileName = decodeURIComponent(fileName);
-            const tempDir = os.tmpdir();
-            const filePath = path.join(tempDir, decodedFileName);
-
-            if (!isPathInside(filePath, tempDir)) {
-                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('Forbidden');
+            let decodedFileName = '';
+            try {
+                decodedFileName = decodeURIComponent(fileName);
+            } catch (_) {
+                res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Bad Request');
                 return;
             }
-            if (!fs.existsSync(filePath)) {
-                res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('File Not Found');
+
+            const artifact = resolveDownloadArtifact(decodedFileName, { consume: true });
+            if (artifact) {
+                streamZipDownloadResponse(res, artifact.filePath, {
+                    fileName: artifact.fileName,
+                    deleteAfterDownload: artifact.deleteAfterDownload !== false
+                });
                 return;
             }
-            const stat = fs.statSync(filePath);
-            if (!stat.isFile()) {
-                res.writeHead(400, { 'Content-Type': 'text/plain; charset=utf-8' });
-                res.end('Not a File');
+
+            const tempDir = os.tmpdir();
+            const legacyFilePath = path.join(tempDir, decodedFileName);
+            if (!isPathInside(legacyFilePath, tempDir)) {
+                res.writeHead(403, { 'Content-Type': 'text/plain; charset=utf-8' });
+                res.end('Forbidden');
                 return;
             }
-            res.writeHead(200, {
-                'Content-Type': 'application/zip',
-                'Content-Disposition': `attachment; filename="${path.basename(filePath)}"`,
-                'Content-Length': stat.size
+            streamZipDownloadResponse(res, legacyFilePath, {
+                fileName: path.basename(legacyFilePath),
+                deleteAfterDownload: false
             });
-            fs.createReadStream(filePath).pipe(res);
         } else if (requestPath.startsWith('/res/')) {
             const normalized = path.normalize(requestPath).replace(/^([\\.\\/])+/, '');
             const filePath = path.join(__dirname, normalized);
@@ -6627,7 +8693,7 @@ function cmdStart(options = {}) {
         webDir,
         host,
         port,
-        openBrowser: true
+        openBrowser: !options.noBrowser
     });
 
     const proxySettings = readBuiltinProxySettings();
@@ -6948,7 +9014,223 @@ async function cmdProxy(args = []) {
         return;
     }
 
-    throw new Error(`未知 proxy 子命令: ${subcommand}`);
+    throw new Error(`未知 proxy 子命令: ${subcommand}`);
+}
+
+function parseWorkflowInputArg(rawInput) {
+    const raw = typeof rawInput === 'string' ? rawInput.trim() : '';
+    if (!raw) {
+        return {};
+    }
+    let content = raw;
+    if (raw.startsWith('@')) {
+        const filePath = path.resolve(raw.slice(1));
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`工作流输入文件不存在: ${filePath}`);
+        }
+        content = fs.readFileSync(filePath, 'utf-8');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    } catch (e) {
+        throw new Error(`工作流输入 JSON 解析失败: ${e.message}`);
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('工作流输入必须是 JSON 对象');
+    }
+    return parsed;
+}
+
+function printWorkflowHelp() {
+    console.log('\n用法: codexmate workflow <list|get|validate|run|runs> [参数]');
+    console.log('  codexmate workflow list');
+    console.log('  codexmate workflow get diagnose-config');
+    console.log('  codexmate workflow validate safe-provider-switch --input \'{"provider":"e2e"}\'');
+    console.log('  codexmate workflow run diagnose-config --input \'{}\'');
+    console.log('  codexmate workflow run safe-provider-switch --input \'{"provider":"e2e","apply":true}\' --allow-write');
+    console.log('  codexmate workflow runs --limit 20');
+    console.log('参数:');
+    console.log('  --input <JSON|@file>  传入工作流输入');
+    console.log('  --allow-write         允许执行写入步骤');
+    console.log('  --dry-run             跳过写入步骤，仅预演');
+    console.log('  --limit <N>           读取最近执行记录数量（runs）');
+    console.log('  --json                以 JSON 输出');
+    console.log();
+}
+
+function parseWorkflowCliOptions(args = []) {
+    const options = {
+        inputRaw: '',
+        allowWrite: false,
+        dryRun: false,
+        limit: 20,
+        json: false
+    };
+    const rest = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--allow-write') {
+            options.allowWrite = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === '--json') {
+            options.json = true;
+            continue;
+        }
+        if (arg === '--input') {
+            options.inputRaw = args[i + 1] || '';
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--input=')) {
+            options.inputRaw = arg.slice('--input='.length);
+            continue;
+        }
+        if (arg === '--limit') {
+            const raw = args[i + 1];
+            i += 1;
+            const value = parseInt(raw, 10);
+            if (Number.isFinite(value)) {
+                options.limit = value;
+            }
+            continue;
+        }
+        if (arg.startsWith('--limit=')) {
+            const value = parseInt(arg.slice('--limit='.length), 10);
+            if (Number.isFinite(value)) {
+                options.limit = value;
+            }
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { options, rest };
+}
+
+async function cmdWorkflow(args = []) {
+    const argv = Array.isArray(args) ? args : [];
+    if (argv.length === 0 || argv.includes('--help') || argv.includes('-h')) {
+        printWorkflowHelp();
+        return;
+    }
+    const subcommand = String(argv[0] || '').trim().toLowerCase();
+    const parsed = parseWorkflowCliOptions(argv.slice(1));
+    const options = parsed.options;
+    const rest = parsed.rest;
+
+    if (subcommand === 'list') {
+        const result = listWorkflowDefinitions();
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const workflows = Array.isArray(result.workflows) ? result.workflows : [];
+        console.log('\n可用工作流:');
+        for (const item of workflows) {
+            const mode = item.readOnly ? 'read-only' : 'read-write';
+            console.log(`  - ${item.id} (${mode}, steps=${item.stepCount})`);
+            if (item.description) {
+                console.log(`    ${item.description}`);
+            }
+        }
+        if (Array.isArray(result.warnings) && result.warnings.length > 0) {
+            console.log('\n警告:');
+            result.warnings.forEach((msg) => console.log(`  - ${msg}`));
+        }
+        console.log();
+        return;
+    }
+
+    if (subcommand === 'runs') {
+        const limit = Number.isFinite(options.limit) ? Math.max(1, Math.floor(options.limit)) : 20;
+        const runs = listWorkflowRunRecords(limit);
+        if (options.json) {
+            console.log(JSON.stringify({ runs, limit }, null, 2));
+            return;
+        }
+        console.log(`\n最近执行记录（${runs.length}/${limit}）:`);
+        for (const item of runs) {
+            const status = item && item.success ? 'OK' : 'FAIL';
+            console.log(`  - [${status}] ${item.workflowId || '(unknown)'} runId=${item.runId || ''} duration=${item.durationMs || 0}ms`);
+            if (item && item.error) {
+                console.log(`    error: ${item.error}`);
+            }
+        }
+        console.log();
+        return;
+    }
+
+    const workflowId = typeof rest[0] === 'string' ? rest[0].trim() : '';
+    if (!workflowId) {
+        throw new Error('workflow id is required');
+    }
+    const input = parseWorkflowInputArg(options.inputRaw);
+
+    if (subcommand === 'get') {
+        const result = getWorkflowDefinitionById(workflowId);
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+
+    if (subcommand === 'validate') {
+        const result = validateWorkflowById(workflowId, input);
+        if (!result.ok) {
+            throw new Error(result.error || 'workflow validate failed');
+        }
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        } else {
+            console.log(`✓ 工作流校验通过: ${workflowId}`);
+            if (Array.isArray(result.warnings) && result.warnings.length > 0) {
+                result.warnings.forEach((msg) => console.log(`  - ${msg}`));
+            }
+            console.log();
+        }
+        return;
+    }
+
+    if (subcommand === 'run') {
+        const result = await runWorkflowById(workflowId, input, {
+            allowWrite: options.allowWrite,
+            dryRun: options.dryRun
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+        } else {
+            if (result.error) {
+                console.error(`✗ 工作流执行失败: ${result.error}`);
+            } else {
+                console.log(`✓ 工作流执行完成: ${workflowId} (${result.durationMs || 0}ms)`);
+            }
+            const steps = Array.isArray(result.steps) ? result.steps : [];
+            for (const step of steps) {
+                const status = step.status || 'unknown';
+                const label = step.id || step.tool || '(step)';
+                console.log(`  - ${label}: ${status} (${step.durationMs || 0}ms)`);
+                if (step.error) {
+                    console.log(`    error: ${step.error}`);
+                }
+            }
+            if (result.runId) {
+                console.log(`  runId: ${result.runId}`);
+            }
+            console.log();
+        }
+        if (result.error) {
+            throw new Error(result.error);
+        }
+        return;
+    }
+
+    throw new Error(`未知 workflow 子命令: ${subcommand}`);
 }
 
 async function runProxyCommand(displayName, binNames, args = [], installTip = '') {
@@ -7023,10 +9305,6 @@ async function cmdQwen(args = []) {
     return runProxyCommand('Qwen', ['qwen', 'qwen-code'], args, 'npm install -g @qwen-code/qwen-code');
 }
 
-async function cmdGemini(args = []) {
-    return runProxyCommand('Gemini', ['gemini', 'gemini-cli'], args, 'npm install -g @google/gemini-cli');
-}
-
 function parseMcpOptions(args = []) {
     const options = {
         subcommand: 'serve',
@@ -7103,6 +9381,7 @@ function buildMcpStatusPayload() {
         serviceTier,
         modelReasoningEffort,
         configReady: !statusConfigResult.isVirtual,
+        configErrorType: statusConfigResult.errorType || '',
         configNotice: statusConfigResult.reason || '',
         initNotice: consumeInitNotice()
     };
@@ -7115,6 +9394,8 @@ function buildMcpProviderListPayload() {
     const current = listConfig.model_provider;
     return {
         configReady: !listConfigResult.isVirtual,
+        configErrorType: listConfigResult.errorType || '',
+        configNotice: listConfigResult.reason || '',
         providers: Object.entries(providers).map(([name, p]) => ({
             name,
             url: p.base_url || '',
@@ -7167,6 +9448,541 @@ function normalizeMcpSource(value) {
     return null;
 }
 
+const BUILTIN_WORKFLOW_DEFINITIONS = Object.freeze({
+    'diagnose-config': {
+        id: 'diagnose-config',
+        name: 'Diagnose Config',
+        description: 'Collect status/providers/proxy snapshots for troubleshooting.',
+        readOnly: true,
+        inputSchema: {
+            type: 'object',
+            properties: {},
+            additionalProperties: false
+        },
+        steps: [
+            { id: 'status', tool: 'codexmate.status.get', arguments: {} },
+            { id: 'providers', tool: 'codexmate.provider.list', arguments: {} },
+            { id: 'proxy', tool: 'codexmate.proxy.status', arguments: {} }
+        ]
+    },
+    'safe-provider-switch': {
+        id: 'safe-provider-switch',
+        name: 'Safe Provider Switch',
+        description: 'Build template for a provider switch and optionally apply it.',
+        readOnly: false,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                provider: { type: 'string' },
+                model: { type: 'string' },
+                serviceTier: { type: 'string' },
+                reasoningEffort: { type: 'string' },
+                apply: { type: 'boolean' }
+            },
+            required: ['provider'],
+            additionalProperties: false
+        },
+        steps: [
+            { id: 'providers', tool: 'codexmate.provider.list', arguments: {} },
+            {
+                id: 'template',
+                tool: 'codexmate.config.template.get',
+                arguments: {
+                    provider: '{{input.provider}}',
+                    model: '{{input.model}}',
+                    serviceTier: '{{input.serviceTier}}',
+                    reasoningEffort: '{{input.reasoningEffort}}'
+                }
+            },
+            {
+                id: 'apply',
+                tool: 'codexmate.config.template.apply',
+                when: { path: 'input.apply', equals: true },
+                arguments: {
+                    template: '{{steps.template.output.template}}'
+                }
+            },
+            {
+                id: 'statusAfter',
+                tool: 'codexmate.status.get',
+                when: { path: 'input.apply', equals: true },
+                arguments: {}
+            }
+        ]
+    },
+    'session-issue-pack': {
+        id: 'session-issue-pack',
+        name: 'Session Issue Pack',
+        description: 'Collect session detail and markdown export for issue reports.',
+        readOnly: true,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: { type: 'string' },
+                sessionId: { type: 'string' },
+                file: { type: 'string' },
+                maxMessages: { type: ['string', 'number'] }
+            },
+            additionalProperties: true
+        },
+        steps: [
+            {
+                id: 'detail',
+                tool: 'codexmate.session.detail',
+                arguments: {
+                    source: '{{input.source}}',
+                    sessionId: '{{input.sessionId}}',
+                    file: '{{input.file}}',
+                    maxMessages: '{{input.maxMessages}}'
+                }
+            },
+            {
+                id: 'export',
+                tool: 'codexmate.session.export',
+                arguments: {
+                    source: '{{input.source}}',
+                    sessionId: '{{input.sessionId}}',
+                    file: '{{input.file}}',
+                    maxMessages: '{{input.maxMessages}}'
+                }
+            }
+        ]
+    }
+});
+
+function cloneJson(value, fallback) {
+    try {
+        return JSON.parse(JSON.stringify(value));
+    } catch (_) {
+        return fallback;
+    }
+}
+
+function normalizeWorkflowId(value) {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (!raw) return '';
+    if (!/^[a-zA-Z0-9._-]+$/.test(raw)) {
+        return '';
+    }
+    return raw.toLowerCase();
+}
+
+function normalizeWorkflowDefinition(raw, idHint = '', source = 'custom') {
+    const safe = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : null;
+    if (!safe) {
+        return { ok: false, error: 'workflow must be an object' };
+    }
+    const id = normalizeWorkflowId(safe.id || idHint);
+    if (!id) {
+        return { ok: false, error: 'workflow id is invalid' };
+    }
+    const name = typeof safe.name === 'string' && safe.name.trim()
+        ? safe.name.trim()
+        : id;
+    const description = typeof safe.description === 'string' ? safe.description.trim() : '';
+    const inputSchema = safe.inputSchema && typeof safe.inputSchema === 'object'
+        ? cloneJson(safe.inputSchema, { type: 'object', properties: {}, additionalProperties: true })
+        : { type: 'object', properties: {}, additionalProperties: true };
+    const stepsRaw = Array.isArray(safe.steps) ? safe.steps : [];
+    if (stepsRaw.length === 0) {
+        return { ok: false, error: 'workflow steps cannot be empty' };
+    }
+
+    const steps = [];
+    for (let i = 0; i < stepsRaw.length; i += 1) {
+        const item = stepsRaw[i];
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            return { ok: false, error: `workflow step #${i + 1} must be an object` };
+        }
+        const stepIdRaw = typeof item.id === 'string' && item.id.trim()
+            ? item.id.trim()
+            : `step${i + 1}`;
+        const stepId = normalizeWorkflowId(stepIdRaw);
+        if (!stepId) {
+            return { ok: false, error: `workflow step id invalid at #${i + 1}` };
+        }
+        const toolName = typeof item.tool === 'string' ? item.tool.trim() : '';
+        if (!toolName) {
+            return { ok: false, error: `workflow step "${stepId}" missing tool` };
+        }
+        const args = item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments)
+            ? cloneJson(item.arguments, {})
+            : {};
+        const when = item.when && typeof item.when === 'object' && !Array.isArray(item.when)
+            ? cloneJson(item.when, {})
+            : null;
+        steps.push({
+            id: stepId,
+            name: typeof item.name === 'string' ? item.name.trim() : '',
+            tool: toolName,
+            arguments: args,
+            when,
+            continueOnError: item.continueOnError === true,
+            write: item.write === true
+        });
+    }
+
+    return {
+        ok: true,
+        data: {
+            id,
+            name,
+            description,
+            source,
+            readOnly: safe.readOnly !== false,
+            inputSchema,
+            steps
+        }
+    };
+}
+
+function loadBuiltinWorkflowDefinitions() {
+    const items = [];
+    for (const [id, raw] of Object.entries(BUILTIN_WORKFLOW_DEFINITIONS)) {
+        const normalized = normalizeWorkflowDefinition(raw, id, 'builtin');
+        if (!normalized.ok) {
+            continue;
+        }
+        items.push(normalized.data);
+    }
+    return items;
+}
+
+function loadCustomWorkflowDefinitions() {
+    const parsed = readJsonObjectFromFile(WORKFLOW_DEFINITIONS_FILE, {});
+    if (!parsed.ok || !parsed.exists) {
+        return {
+            items: [],
+            warnings: parsed.ok ? [] : [parsed.error || 'workflow file parse failed']
+        };
+    }
+    const data = parsed.data && typeof parsed.data === 'object' ? parsed.data : {};
+    let list = [];
+    if (Array.isArray(data.workflows)) {
+        list = data.workflows;
+    } else if (data.workflows && typeof data.workflows === 'object') {
+        list = Object.entries(data.workflows).map(([id, item]) => ({ ...(item || {}), id }));
+    } else {
+        list = Object.entries(data).map(([id, item]) => ({ ...(item || {}), id }));
+    }
+
+    const items = [];
+    const warnings = [];
+    for (const item of list) {
+        const normalized = normalizeWorkflowDefinition(item, item && item.id ? item.id : '', 'custom');
+        if (!normalized.ok) {
+            warnings.push(normalized.error || 'invalid custom workflow');
+            continue;
+        }
+        items.push(normalized.data);
+    }
+    return { items, warnings };
+}
+
+function buildWorkflowRegistry() {
+    const registry = new Map();
+    const warnings = [];
+    const builtin = loadBuiltinWorkflowDefinitions();
+    for (const item of builtin) {
+        registry.set(item.id, item);
+    }
+    const custom = loadCustomWorkflowDefinitions();
+    for (const item of custom.items) {
+        if (registry.has(item.id)) {
+            warnings.push(`custom workflow id duplicated with builtin and ignored: ${item.id}`);
+            continue;
+        }
+        registry.set(item.id, item);
+    }
+    warnings.push(...custom.warnings);
+    return { registry, warnings };
+}
+
+function listWorkflowDefinitions() {
+    const { registry, warnings } = buildWorkflowRegistry();
+    const workflows = Array.from(registry.values())
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map((item) => ({
+            id: item.id,
+            name: item.name,
+            description: item.description,
+            source: item.source,
+            readOnly: item.readOnly !== false,
+            stepCount: Array.isArray(item.steps) ? item.steps.length : 0
+        }));
+    return {
+        workflows,
+        warnings
+    };
+}
+
+function getWorkflowDefinitionById(rawId) {
+    const id = normalizeWorkflowId(rawId);
+    if (!id) {
+        return { error: 'workflow id is required' };
+    }
+    const { registry, warnings } = buildWorkflowRegistry();
+    const workflow = registry.get(id);
+    if (!workflow) {
+        return { error: `workflow not found: ${id}` };
+    }
+    return {
+        workflow: cloneJson(workflow, {}),
+        warnings
+    };
+}
+
+function createWorkflowToolCatalog() {
+    return {
+        'codexmate.status.get': {
+            readOnly: true,
+            handler: async () => buildMcpStatusPayload()
+        },
+        'codexmate.provider.list': {
+            readOnly: true,
+            handler: async () => buildMcpProviderListPayload()
+        },
+        'codexmate.proxy.status': {
+            readOnly: true,
+            handler: async () => getBuiltinProxyStatus()
+        },
+        'codexmate.session.list': {
+            readOnly: true,
+            handler: async (args = {}) => {
+                const source = normalizeMcpSource(args.source);
+                if (source === null) {
+                    return { error: 'Invalid source. Must be codex, claude, or all' };
+                }
+                return {
+                    source: source || 'all',
+                    sessions: listAllSessions({
+                        ...args,
+                        source: source || 'all'
+                    })
+                };
+            }
+        },
+        'codexmate.session.detail': {
+            readOnly: true,
+            handler: async (args = {}) => readSessionDetail(args || {})
+        },
+        'codexmate.session.export': {
+            readOnly: true,
+            handler: async (args = {}) => exportSessionData(args || {})
+        },
+        'codexmate.config.template.get': {
+            readOnly: true,
+            handler: async (args = {}) => getConfigTemplate(args || {})
+        },
+        'codexmate.config.template.apply': {
+            readOnly: false,
+            handler: async (args = {}) => applyConfigTemplate(args || {})
+        }
+    };
+}
+
+function getWorkflowKnownToolsSet() {
+    return new Set(Object.keys(createWorkflowToolCatalog()));
+}
+
+function resolveWorkflowDefinitionWithToolMeta(workflow) {
+    const catalog = createWorkflowToolCatalog();
+    const safe = cloneJson(workflow, {});
+    safe.steps = (Array.isArray(safe.steps) ? safe.steps : []).map((step) => {
+        const tool = catalog[step.tool];
+        return {
+            ...step,
+            write: step.write === true || !!(tool && tool.readOnly === false)
+        };
+    });
+    return safe;
+}
+
+function validateWorkflowInputBySchema(inputSchema, input) {
+    const schema = inputSchema && typeof inputSchema === 'object' ? inputSchema : {};
+    if (schema.type && schema.type !== 'object') {
+        return { ok: false, error: `unsupported input schema type: ${schema.type}` };
+    }
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        return { ok: false, error: 'workflow input must be an object' };
+    }
+    const required = Array.isArray(schema.required) ? schema.required : [];
+    for (const key of required) {
+        if (!Object.prototype.hasOwnProperty.call(input, key)) {
+            return { ok: false, error: `missing required input field: ${key}` };
+        }
+    }
+    const properties = schema.properties && typeof schema.properties === 'object' ? schema.properties : {};
+    for (const [key, expected] of Object.entries(properties)) {
+        if (!Object.prototype.hasOwnProperty.call(input, key)) continue;
+        const value = input[key];
+        if (!expected || typeof expected !== 'object') continue;
+        const type = expected.type;
+        if (!type) continue;
+        const typeList = Array.isArray(type) ? type : [type];
+        const actualType = value === null ? 'null' : (Array.isArray(value) ? 'array' : typeof value);
+        const matched = typeList.some((candidate) => {
+            if (candidate === 'number') return typeof value === 'number' && Number.isFinite(value);
+            if (candidate === 'integer') return Number.isInteger(value);
+            if (candidate === 'array') return Array.isArray(value);
+            if (candidate === 'object') return value && typeof value === 'object' && !Array.isArray(value);
+            if (candidate === 'null') return value === null;
+            return actualType === candidate;
+        });
+        if (!matched) {
+            return { ok: false, error: `input field "${key}" type mismatch` };
+        }
+    }
+    return { ok: true };
+}
+
+function appendWorkflowRunRecord(record) {
+    ensureDir(path.dirname(WORKFLOW_RUNS_FILE));
+    const content = `${JSON.stringify(record)}\n`;
+    fs.appendFileSync(WORKFLOW_RUNS_FILE, content, { encoding: 'utf-8', mode: 0o600 });
+}
+
+function listWorkflowRunRecords(limit = 20) {
+    const max = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 20;
+    if (!fs.existsSync(WORKFLOW_RUNS_FILE)) {
+        return [];
+    }
+    let content = '';
+    try {
+        content = fs.readFileSync(WORKFLOW_RUNS_FILE, 'utf-8');
+    } catch (_) {
+        return [];
+    }
+    const rows = content
+        .split(/\r?\n/g)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const parsed = [];
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        try {
+            const item = JSON.parse(rows[i]);
+            parsed.push(item);
+            if (parsed.length >= max) {
+                break;
+            }
+        } catch (_) {}
+    }
+    return parsed;
+}
+
+function validateWorkflowById(workflowId, input = {}) {
+    const definitionResult = getWorkflowDefinitionById(workflowId);
+    if (definitionResult.error) {
+        return { ok: false, error: definitionResult.error };
+    }
+    const workflow = resolveWorkflowDefinitionWithToolMeta(definitionResult.workflow);
+    const knownTools = getWorkflowKnownToolsSet();
+    const validation = validateWorkflowDefinition(workflow, { knownTools });
+    if (!validation.ok) {
+        return {
+            ok: false,
+            error: validation.error || 'workflow validation failed',
+            issues: validation.issues || []
+        };
+    }
+    const schemaValidation = validateWorkflowInputBySchema(workflow.inputSchema, input || {});
+    if (!schemaValidation.ok) {
+        return { ok: false, error: schemaValidation.error || 'workflow input validation failed' };
+    }
+    return {
+        ok: true,
+        workflow: {
+            id: workflow.id,
+            name: workflow.name,
+            readOnly: workflow.readOnly !== false,
+            stepCount: Array.isArray(workflow.steps) ? workflow.steps.length : 0
+        },
+        warnings: definitionResult.warnings || []
+    };
+}
+
+async function runWorkflowById(workflowId, input = {}, options = {}) {
+    const definitionResult = getWorkflowDefinitionById(workflowId);
+    if (definitionResult.error) {
+        return { error: definitionResult.error };
+    }
+    const workflow = resolveWorkflowDefinitionWithToolMeta(definitionResult.workflow);
+    const knownTools = getWorkflowKnownToolsSet();
+    const validation = validateWorkflowDefinition(workflow, { knownTools });
+    if (!validation.ok) {
+        return {
+            error: validation.error || 'workflow validation failed',
+            issues: validation.issues || []
+        };
+    }
+    const schemaValidation = validateWorkflowInputBySchema(workflow.inputSchema, input || {});
+    if (!schemaValidation.ok) {
+        return { error: schemaValidation.error || 'workflow input validation failed' };
+    }
+
+    const catalog = createWorkflowToolCatalog();
+    const allowWrite = options.allowWrite === true;
+    const dryRun = options.dryRun === true;
+    const runId = `wf-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
+    const startedAt = toIsoTime(Date.now());
+
+    const execution = await executeWorkflowDefinition(workflow, input || {}, {
+        allowWrite,
+        dryRun,
+        invokeTool: async (toolName, args = {}) => {
+            const tool = catalog[toolName];
+            if (!tool) {
+                return { error: `workflow tool not supported: ${toolName}` };
+            }
+            if (!tool.readOnly && !allowWrite) {
+                return { error: `workflow requires write permission for tool: ${toolName}` };
+            }
+            return tool.handler(args || {});
+        }
+    });
+
+    const endedAt = toIsoTime(Date.now());
+    const record = {
+        runId,
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+        success: execution.success === true,
+        error: execution.error || '',
+        allowWrite,
+        dryRun,
+        startedAt,
+        endedAt,
+        durationMs: execution.durationMs || 0,
+        steps: Array.isArray(execution.steps) ? execution.steps.map((step) => ({
+            id: step.id,
+            tool: step.tool,
+            status: step.status,
+            durationMs: step.durationMs || 0,
+            error: step.error || ''
+        })) : [],
+        input: cloneJson(input || {}, {})
+    };
+    try {
+        appendWorkflowRunRecord(record);
+    } catch (_) {}
+
+    return {
+        success: execution.success === true,
+        runId,
+        workflowId: workflow.id,
+        workflowName: workflow.name,
+        allowWrite,
+        dryRun,
+        startedAt: execution.startedAt || startedAt,
+        endedAt: execution.endedAt || endedAt,
+        durationMs: execution.durationMs || 0,
+        steps: execution.steps || [],
+        output: execution.output || null,
+        warnings: definitionResult.warnings || [],
+        ...(execution.error ? { error: execution.error } : {})
+    };
+}
+
 function createMcpTools(options = {}) {
     const allowWrite = !!options.allowWrite;
     const tools = [];
@@ -7362,6 +10178,89 @@ function createMcpTools(options = {}) {
         handler: async () => getBuiltinProxyStatus()
     });
 
+    pushTool({
+        name: 'codexmate.workflow.list',
+        description: 'List available workflows (builtin + custom).',
+        readOnly: true,
+        inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        handler: async () => listWorkflowDefinitions()
+    });
+
+    pushTool({
+        name: 'codexmate.workflow.get',
+        description: 'Get one workflow definition by id.',
+        readOnly: true,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' }
+            },
+            required: ['id'],
+            additionalProperties: false
+        },
+        handler: async (args = {}) => {
+            const id = typeof args.id === 'string' ? args.id.trim() : '';
+            if (!id) {
+                return { error: 'workflow id is required' };
+            }
+            return getWorkflowDefinitionById(id);
+        }
+    });
+
+    pushTool({
+        name: 'codexmate.workflow.validate',
+        description: 'Validate workflow definition and input payload.',
+        readOnly: true,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                input: { type: 'object' }
+            },
+            required: ['id'],
+            additionalProperties: false
+        },
+        handler: async (args = {}) => {
+            const id = typeof args.id === 'string' ? args.id.trim() : '';
+            if (!id) {
+                return { ok: false, error: 'workflow id is required' };
+            }
+            const input = args.input && typeof args.input === 'object' && !Array.isArray(args.input)
+                ? args.input
+                : {};
+            return validateWorkflowById(id, input);
+        }
+    });
+
+    pushTool({
+        name: 'codexmate.workflow.run',
+        description: 'Run workflow by id. Write steps require allow-write mode.',
+        readOnly: true,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                input: { type: 'object' },
+                dryRun: { type: 'boolean' }
+            },
+            required: ['id'],
+            additionalProperties: false
+        },
+        handler: async (args = {}) => {
+            const id = typeof args.id === 'string' ? args.id.trim() : '';
+            if (!id) {
+                return { error: 'workflow id is required' };
+            }
+            const input = args.input && typeof args.input === 'object' && !Array.isArray(args.input)
+                ? args.input
+                : {};
+            return runWorkflowById(id, input, {
+                allowWrite,
+                dryRun: args.dryRun === true
+            });
+        }
+    });
+
     pushTool({
         name: 'codexmate.config.template.apply',
         description: 'Apply Codex TOML template and sync auth/model pointers.',
@@ -7636,6 +10535,50 @@ function createMcpResources() {
                     }]
                 };
             }
+        },
+        {
+            uri: 'codexmate://workflows',
+            name: 'Workflows',
+            description: 'Workflow list resource (builtin + custom).',
+            mimeType: 'application/json',
+            read: async () => ({
+                contents: [{
+                    uri: 'codexmate://workflows',
+                    mimeType: 'application/json',
+                    text: JSON.stringify(listWorkflowDefinitions(), null, 2)
+                }]
+            })
+        },
+        {
+            uri: 'codexmate://workflow-runs',
+            name: 'WorkflowRuns',
+            description: 'Recent workflow execution records. Supports ?limit=<N>.',
+            mimeType: 'application/json',
+            read: async (params = {}) => {
+                const uri = typeof params.uri === 'string' ? params.uri : 'codexmate://workflow-runs';
+                let limit = 20;
+                try {
+                    const parsed = new URL(uri);
+                    const rawLimit = parsed.searchParams.get('limit');
+                    if (rawLimit) {
+                        const parsedLimit = parseInt(rawLimit, 10);
+                        if (Number.isFinite(parsedLimit)) {
+                            limit = parsedLimit;
+                        }
+                    }
+                } catch (_) {}
+                const payload = {
+                    runs: listWorkflowRunRecords(limit),
+                    limit: Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 20
+                };
+                return {
+                    contents: [{
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(payload, null, 2)
+                    }]
+                };
+            }
         }
     ];
 }
@@ -7820,10 +10763,10 @@ async function main() {
         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 run [--host <HOST>]    启动 Web 界面');
+        console.log('  codexmate workflow <list|get|validate|run|runs>  MCP 工作流中心');
+        console.log('  codexmate run [--host <HOST>] [--no-browser]    启动 Web 界面');
         console.log('  codexmate codex [参数...]  等同于 codex --yolo');
         console.log('  codexmate qwen [参数...]   等同于 qwen --yolo');
-        console.log('  codexmate gemini [参数...] 等同于 gemini --yolo');
         console.log('  codexmate mcp [serve] [--transport stdio] [--allow-write|--read-only]');
         console.log('  codexmate export-session --source <codex|claude> (--session-id <ID>|--file <PATH>) [--output <PATH>] [--max-messages <N|all|Infinity>]');
         console.log('  codexmate zip <路径> [--max:级别]  压缩（系统 zip 优先，其次 zip-lib）');
@@ -7846,6 +10789,7 @@ async function main() {
         case 'delete-model': cmdDeleteModel(args[1]); break;
         case 'auth': cmdAuth(args.slice(1)); break;
         case 'proxy': await cmdProxy(args.slice(1)); break;
+        case 'workflow': await cmdWorkflow(args.slice(1)); break;
         case 'run': cmdStart(parseStartOptions(args.slice(1))); break;
         case 'start':
             console.error('错误: 命令已更名为 "run"，请使用: codexmate run');
@@ -7861,11 +10805,6 @@ async function main() {
             process.exit(exitCode);
             break;
         }
-        case 'gemini': {
-            const exitCode = await cmdGemini(args.slice(1));
-            process.exit(exitCode);
-            break;
-        }
         case 'mcp': await cmdMcp(args.slice(1)); break;
         case 'export-session': await cmdExportSession(args.slice(1)); break;
         case 'zip': {