codexmate 0.1.7 → 0.1.8

package/cli/system-prompt-files.js

@@ -0,0 +1,177 @@
+'use strict';
+
+function createSystemPromptFileController(deps = {}) {
+    const {
+        fs,
+        path,
+        os,
+        crypto,
+        buildLineDiff,
+        CONFIG_DIR,
+        PI_AGENT_DIR
+    } = deps;
+
+    if (!fs) throw new Error('createSystemPromptFileController 缺少 fs');
+    if (!path) throw new Error('createSystemPromptFileController 缺少 path');
+    if (!os) throw new Error('createSystemPromptFileController 缺少 os');
+    if (!crypto) throw new Error('createSystemPromptFileController 缺少 crypto');
+    if (typeof buildLineDiff !== 'function') throw new Error('createSystemPromptFileController 缺少 buildLineDiff');
+    if (typeof CONFIG_DIR !== 'string' || !CONFIG_DIR) throw new Error('createSystemPromptFileController 缺少 CONFIG_DIR');
+    if (typeof PI_AGENT_DIR !== 'string' || !PI_AGENT_DIR) throw new Error('createSystemPromptFileController 缺少 PI_AGENT_DIR');
+
+    const MODES = {
+        system: 'SYSTEM.md',
+        append: 'APPEND_SYSTEM.md'
+    };
+
+    const SCOPES = ['global', 'project'];
+
+    function normalizeMode(mode) {
+        const key = typeof mode === 'string' ? mode.trim() : '';
+        if (!Object.prototype.hasOwnProperty.call(MODES, key)) {
+            throw new Error("Invalid system prompt mode: expected 'system' or 'append'");
+        }
+        return key;
+    }
+
+    function normalizeScope(scope) {
+        const key = typeof scope === 'string' ? scope.trim() : '';
+        if (!SCOPES.includes(key)) {
+            throw new Error("Invalid system prompt scope: expected 'global' or 'project'");
+        }
+        return key;
+    }
+
+    function hashContent(content) {
+        return crypto.createHash('sha256').update(String(content || '')).digest('hex');
+    }
+
+    function resolveSystemPromptFilePath(params = {}) {
+        const scope = normalizeScope(params.scope);
+        const mode = normalizeMode(params.mode);
+        const filename = MODES[mode];
+        let base;
+        if (scope === 'global') {
+            base = PI_AGENT_DIR;
+        } else {
+            const cwd = typeof params.cwd === 'string' && params.cwd.trim()
+                ? params.cwd.trim()
+                : process.cwd();
+            base = path.join(path.resolve(cwd), '.pi');
+        }
+        return {
+            scope,
+            mode,
+            filename,
+            path: path.join(base, filename),
+            replaceDefault: mode === 'system'
+        };
+    }
+
+    function readSystemPromptFile(params = {}) {
+        const target = resolveSystemPromptFilePath(params);
+        const exists = fs.existsSync(target.path);
+        let content = '';
+        if (exists) {
+            try {
+                content = fs.readFileSync(target.path, 'utf8');
+            } catch (e) {
+                return { ...target, exists: false, content: '', hash: hashContent(''), error: '读取 system prompt 失败: ' + e.message };
+            }
+        }
+        return {
+            ...target,
+            exists,
+            content,
+            hash: hashContent(content)
+        };
+    }
+
+    function saveSystemPromptFile(params = {}) {
+        const content = typeof params.content === 'string' ? params.content : '';
+        if (!content.trim()) {
+            return { error: 'System prompt 不能为空' };
+        }
+        if (content.length > 2 * 1024 * 1024) {
+            return { error: '内容过大（最大 2MB）' };
+        }
+        const target = resolveSystemPromptFilePath(params);
+        const current = readSystemPromptFilePath(target);
+        if (current.error) {
+            return { error: current.error };
+        }
+        const baseHash = typeof params.baseHash === 'string' ? params.baseHash.trim() : '';
+        if (baseHash && baseHash !== current.hash) {
+            return { error: '文件已被外部修改，请重新加载后再保存' };
+        }
+        try {
+            const dir = path.dirname(target.path);
+            fs.mkdirSync(dir, { recursive: true });
+            const finalContent = content.endsWith('\n') ? content : content + '\n';
+            fs.writeFileSync(target.path, finalContent, { encoding: 'utf8', mode: 0o600 });
+            try { fs.chmodSync(target.path, 0o600); } catch (_) {}
+        } catch (e) {
+            return { error: '写入 system prompt 失败: ' + e.message };
+        }
+        return readSystemPromptFilePath(target);
+    }
+
+    function readSystemPromptFilePath(resolved) {
+        const exists = fs.existsSync(resolved.path);
+        let content = '';
+        if (exists) {
+            try {
+                content = fs.readFileSync(resolved.path, 'utf8');
+            } catch (e) {
+                return { ...resolved, exists: false, content: '', hash: hashContent(''), error: '读取 system prompt 失败: ' + e.message };
+            }
+        }
+        return {
+            ...resolved,
+            exists,
+            content,
+            hash: hashContent(content)
+        };
+    }
+
+    function buildSystemPromptDiff(params = {}) {
+        const hasBaseContent = typeof params.baseContent === 'string';
+        const target = resolveSystemPromptFilePath(params);
+        const current = readSystemPromptFilePath(target);
+        if (current.error) {
+            return { error: current.error };
+        }
+        const beforeText = hasBaseContent
+            ? (typeof params.baseContent === 'string' ? params.baseContent : '')
+            : (current.content || '');
+        const afterText = typeof params.content === 'string' ? params.content : '';
+        const normalizedBefore = beforeText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const normalizedAfter = afterText.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const diff = buildLineDiff(normalizedBefore, normalizedAfter);
+        const hasChanges = diff.truncated
+            ? normalizedBefore !== normalizedAfter
+            : (diff.stats.added > 0 || diff.stats.removed > 0);
+        return {
+            diff: {
+                ...diff,
+                hasChanges
+            },
+            path: target.path,
+            exists: current.exists,
+            scope: target.scope,
+            mode: target.mode
+        };
+    }
+
+    return {
+        readSystemPromptFile,
+        saveSystemPromptFile,
+        buildSystemPromptDiff,
+        normalizeMode,
+        normalizeScope
+    };
+}
+
+module.exports = {
+    createSystemPromptFileController
+};

package/cli.js

@@ -126,6 +126,9 @@ const {
 const {
     createAgentsFileController
 } = require('./cli/agents-files');
+const {
+    createSystemPromptFileController
+} = require('./cli/system-prompt-files');
 const {
     createArchiveHelperController
 } = require('./cli/archive-helpers');
@@ -308,6 +311,7 @@ const FAST_SESSION_DETAIL_PREVIEW_FILE_BYTES = 256 * 1024;
 const FAST_SESSION_DETAIL_PREVIEW_CHUNK_BYTES = 64 * 1024;
 const FAST_SESSION_DETAIL_PREVIEW_MAX_BYTES = 1024 * 1024;
 const AGENTS_FILE_NAME = 'AGENTS.md';
+const PI_AGENT_DIR = path.join(os.homedir(), '.pi', 'agent');
 const MODELS_CACHE_TTL_MS = 60 * 1000;
 const MODELS_NEGATIVE_CACHE_TTL_MS = 5 * 1000;
 const MODELS_CACHE_MAX_ENTRIES = 50;
@@ -2102,6 +2106,20 @@ const {
     }
 });
 
+const {
+    readSystemPromptFile,
+    saveSystemPromptFile,
+    buildSystemPromptDiff
+} = createSystemPromptFileController({
+    fs,
+    path,
+    os,
+    crypto,
+    buildLineDiff,
+    CONFIG_DIR,
+    PI_AGENT_DIR
+});
+
 const {
     readOpenclawConfigFile,
     applyOpenclawConfig,
@@ -13479,6 +13497,15 @@ function createWebServer({ htmlPath, assetsDir, webDir, host, port, openBrowser
                         case 'apply-openclaw-workspace-file':
                             result = applyOpenclawWorkspaceFile(params || {});
                             break;
+                        case 'get-system-prompt':
+                            result = readSystemPromptFile(params || {});
+                            break;
+                        case 'apply-system-prompt':
+                            result = saveSystemPromptFile(params || {});
+                            break;
+                        case 'preview-system-prompt-diff':
+                            result = buildSystemPromptDiff(params || {});
+                            break;
                         case 'switch':
                         case 'use':
                         case 'add':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codexmate",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Codex/Claude Code/OpenClaw 配置、会话与任务编排 CLI + Web 工具",
   "main": "cli.js",
   "bin": {

package/web-ui/app.js

@@ -154,6 +154,25 @@ document.addEventListener('DOMContentLoaded', () => {
                 agentsContext: 'codex',
                 agentsModalTitle: 'AGENTS.md 编辑器',
                 agentsModalHint: '保存后会写入目标 AGENTS.md（与 config.toml 同级）。',
+                sysPromptScope: 'global',
+                sysPromptMode: 'append',
+                sysPromptContent: '',
+                sysPromptOriginalContent: '',
+                sysPromptPath: '',
+                sysPromptExists: false,
+                sysPromptHash: '',
+                sysPromptLoading: false,
+                sysPromptSaving: false,
+                sysPromptDiffVisible: false,
+                sysPromptDiffLoading: false,
+                sysPromptDiffError: '',
+                sysPromptDiffLines: [],
+                sysPromptDiffStats: { added: 0, removed: 0, unchanged: 0 },
+                sysPromptDiffTruncated: false,
+                sysPromptDiffHasChangesValue: false,
+                sysPromptDiffFingerprint: '',
+                _sysPromptDiffPreviewRequestToken: null,
+                _sysPromptOpenRequestToken: null,
                 skillsTargetApp: 'codex',
                 skillsRootPath: '',
                 skillsList: [],

package/web-ui/modules/app.computed.session.mjs

@@ -773,7 +773,7 @@ export function createSessionComputed() {
             const rows = currentKeys
                 .map((key) => byDay.get(key))
                 .filter(Boolean)
-                .sort((a, b) => b.key.localeCompare(a.key, 'en-US'));
+                .sort((a, b) => a.key.localeCompare(b.key, 'en-US'));
             const rowsWithCompare = rows.map((row) => {
                 if (!compareEnabled) {
                     return { ...row, compareEnabled: false, prevKey: '', prevTokenTotal: 0 };

package/web-ui/modules/app.methods.agents.mjs

@@ -4,6 +4,7 @@ import {
     isAgentsDiffPreviewPayloadTooLarge,
     shouldApplyAgentsDiffPreviewResponse
 } from '../logic.mjs';
+import { issueLatestRequestToken, isLatestRequestToken } from './request-token.mjs';
 
 function isValidOpenclawWorkspaceFileName(fileName) {
     if (typeof fileName !== 'string') {
@@ -19,16 +20,6 @@ function isValidOpenclawWorkspaceFileName(fileName) {
     return true;
 }
 
-function issueLatestRequestToken(context, key) {
-    const token = (Number(context[key]) || 0) + 1;
-    context[key] = token;
-    return token;
-}
-
-function isLatestRequestToken(context, key, token) {
-    return !!context && context[key] === token;
-}
-
 export function createAgentsMethods(options = {}) {
     const {
         api,
@@ -894,15 +885,17 @@ export function createAgentsMethods(options = {}) {
             this.showMessage(this.t('prompts.presets.toast.deleted'), 'success');
         },
         switchPromptsSubTab(subTab) {
-            const normalized = subTab === 'claude-project' ? subTab : 'codex';
+            const normalized = subTab === 'claude-project' || subTab === 'system' ? subTab : 'codex';
             if (normalized === 'claude-project' && !this.projectPathOptions.length && !this.projectPathOptionsLoading) {
                 this.loadProjectPathOptions();
             }
             if (this.promptsSubTab === normalized) {
-                this.loadPromptsContent();
+                if (normalized === 'system') this.loadSystemPrompt();
+                else this.loadPromptsContent();
                 return;
             }
             this.promptsSubTab = normalized;
+            if (normalized === 'system') this.loadSystemPrompt();
             this.$nextTick(() => {
                 document.querySelector('.main-panel')?.scrollTo({ top: 0, left: 0, behavior: 'auto' });
             });

package/web-ui/modules/app.methods.index.mjs

@@ -12,6 +12,7 @@ import {
     SESSION_TRASH_PAGE_SIZE
 } from './app.constants.mjs';
 import { createAgentsMethods } from './app.methods.agents.mjs';
+import { createSystemPromptMethods } from './app.methods.system-prompt.mjs';
 import { createClaudeConfigMethods } from './app.methods.claude-config.mjs';
 import { createCodexConfigMethods } from './app.methods.codex-config.mjs';
 import { createInstallMethods } from './app.methods.install.mjs';
@@ -85,6 +86,7 @@ export function createAppMethods() {
         ...createSkillsMethods({ api }),
         ...createPluginsMethods(),
         ...createAgentsMethods({ api, apiWithMeta }),
+        ...createSystemPromptMethods({ api, apiWithMeta }),
         ...createProvidersMethods({ api }),
         ...createProviderCacheMethods({ api }),
         ...createWebUiPreferencesMethods({ api }),

package/web-ui/modules/app.methods.session-browser.mjs

@@ -783,6 +783,7 @@ export function createSessionBrowserMethods(options = {}) {
                 this.sessionsUsageCompareEnabled = false;
             }
             void this.loadSessionsUsage({ range });
+            this.scrollSessionsUsageDayIntoView({ behavior: 'auto' });
         },
 
         toggleSessionsUsageCompare() {
@@ -801,12 +802,29 @@ export function createSessionBrowserMethods(options = {}) {
         selectSessionsUsageDay(dayKey) {
             const normalized = typeof dayKey === 'string' ? dayKey.trim() : '';
             this.sessionsUsageSelectedDayKey = normalized;
+            this.scrollSessionsUsageDayIntoView({ behavior: 'smooth', align: 'nearest' });
         },
 
         clearSessionsUsageDay() {
             this.sessionsUsageSelectedDayKey = '';
         },
 
+        scrollSessionsUsageDayIntoView(options = {}) {
+            if (typeof document === 'undefined' || !document) return;
+            const behavior = options.behavior === 'smooth' ? 'smooth' : 'auto';
+            const inline = options.align === 'nearest' ? 'nearest' : 'end';
+            const scrollFn = () => {
+                const node = document.querySelector('.usage-wave-label.active');
+                if (!node || typeof node.scrollIntoView !== 'function') return;
+                node.scrollIntoView({ inline, block: 'nearest', behavior });
+            };
+            if (typeof this.$nextTick === 'function') {
+                this.$nextTick(scrollFn);
+            } else {
+                scrollFn();
+            }
+        },
+
         async loadSessionsUsage(options = {}) {
             if (this.sessionsUsageLoading) return;
             const normalizedRange = typeof options.range === 'string'
@@ -855,7 +873,9 @@ export function createSessionBrowserMethods(options = {}) {
                     this.sessionsUsageLoadedLimit = limit;
                     this.sessionsUsageLastLoadedRange = range;
                     if (!this.sessionsUsageSelectedDayKey && Array.isArray(this.sessionUsageDailyTableRows) && this.sessionUsageDailyTableRows.length > 0) {
-                        this.sessionsUsageSelectedDayKey = this.sessionUsageDailyTableRows[0].key;
+                        const dayKeys = this.sessionUsageDailyTableRows.map((row) => row.key).filter(Boolean).sort((a, b) => b.localeCompare(a, 'en-US'));
+                        this.sessionsUsageSelectedDayKey = dayKeys[0] || this.sessionUsageDailyTableRows[this.sessionUsageDailyTableRows.length - 1].key;
+                        this.scrollSessionsUsageDayIntoView({ behavior: 'auto' });
                     }
                 }
             }

package/web-ui/modules/app.methods.system-prompt.mjs

@@ -0,0 +1,294 @@
+import {
+    buildAgentsDiffPreview,
+    buildAgentsDiffPreviewRequest,
+    isAgentsDiffPreviewPayloadTooLarge,
+    shouldApplyAgentsDiffPreviewResponse
+} from '../logic.mjs';
+import { issueLatestRequestToken, isLatestRequestToken } from './request-token.mjs';
+
+export function createSystemPromptMethods(options = {}) {
+    const {
+        api,
+        apiWithMeta
+    } = options;
+
+    return {
+
+        switchSysPromptScope(scope) {
+            if (this.sysPromptLoading || this.sysPromptSaving) return;
+            const normalized = scope === 'project' ? scope : 'global';
+            if (normalized === this.sysPromptScope) return;
+            this.sysPromptScope = normalized;
+            this.loadSystemPrompt();
+        },
+
+        switchSysPromptMode(mode) {
+            if (this.sysPromptLoading || this.sysPromptSaving) return;
+            const normalized = mode === 'system' ? mode : 'append';
+            if (normalized === this.sysPromptMode) return;
+            this.sysPromptMode = normalized;
+            this.loadSystemPrompt();
+        },
+
+        resetSysPromptDiffState() {
+            this.sysPromptDiffVisible = false;
+            this.sysPromptDiffLoading = false;
+            this.sysPromptDiffError = '';
+            this.sysPromptDiffLines = [];
+            this.sysPromptDiffStats = { added: 0, removed: 0, unchanged: 0 };
+            this.sysPromptDiffTruncated = false;
+            this.sysPromptDiffHasChangesValue = false;
+            this.sysPromptDiffFingerprint = '';
+            this._sysPromptDiffPreviewRequestToken = null;
+        },
+
+        hasSysPromptContentChanged() {
+            const original = typeof this.sysPromptOriginalContent === 'string' ? this.sysPromptOriginalContent : '';
+            const current = typeof this.sysPromptContent === 'string' ? this.sysPromptContent : '';
+            return original !== current;
+        },
+
+        buildSysPromptDiffFingerprint() {
+            const scope = this.sysPromptScope || 'global';
+            const mode = this.sysPromptMode || 'append';
+            const content = typeof this.sysPromptContent === 'string' ? this.sysPromptContent : '';
+            const original = typeof this.sysPromptOriginalContent === 'string' ? this.sysPromptOriginalContent : '';
+            return `${scope}::${mode}::${content.length}::${content}::${original.length}::${original}`;
+        },
+
+        async loadSystemPrompt() {
+            const requestToken = issueLatestRequestToken(this, '_sysPromptOpenRequestToken');
+            this.sysPromptLoading = true;
+            this.resetSysPromptDiffState();
+            try {
+                const params = {
+                    scope: this.sysPromptScope || 'global',
+                    mode: this.sysPromptMode || 'append'
+                };
+                const res = await api('get-system-prompt', params);
+                if (!isLatestRequestToken(this, '_sysPromptOpenRequestToken', requestToken)) return;
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                this.sysPromptContent = res.content || '';
+                this.sysPromptOriginalContent = this.sysPromptContent;
+                this.sysPromptPath = res.path || '';
+                this.sysPromptExists = !!res.exists;
+                this.sysPromptHash = res.hash || '';
+            } catch (e) {
+                if (!isLatestRequestToken(this, '_sysPromptOpenRequestToken', requestToken)) return;
+                this.showMessage(this.t('toast.load.fail'), 'error');
+            } finally {
+                if (isLatestRequestToken(this, '_sysPromptOpenRequestToken', requestToken)) {
+                    this.sysPromptLoading = false;
+                }
+            }
+        },
+
+        async prepareSysPromptDiff() {
+            const requestFingerprint = this.buildSysPromptDiffFingerprint();
+            const requestToken = Symbol('sys-prompt-diff-preview');
+            this._sysPromptDiffPreviewRequestToken = requestToken;
+            this.sysPromptDiffVisible = true;
+            this.sysPromptDiffLoading = true;
+            this.sysPromptDiffError = '';
+            this.sysPromptDiffLines = [];
+            this.sysPromptDiffStats = { added: 0, removed: 0, unchanged: 0 };
+            this.sysPromptDiffTruncated = false;
+            this.sysPromptDiffHasChangesValue = false;
+            try {
+                const shouldApplyPreviewState = () => shouldApplyAgentsDiffPreviewResponse({
+                    isVisible: this.sysPromptDiffVisible,
+                    requestToken,
+                    activeRequestToken: this._sysPromptDiffPreviewRequestToken,
+                    requestFingerprint,
+                    currentFingerprint: this.buildSysPromptDiffFingerprint()
+                });
+                const applyPreviewState = (diff) => {
+                    if (!shouldApplyPreviewState()) return false;
+                    const normalizedDiff = diff && typeof diff === 'object' ? diff : {};
+                    const rawLines = Array.isArray(normalizedDiff.lines) ? normalizedDiff.lines : [];
+                    this.sysPromptDiffLines = rawLines.filter(line => line && line.type);
+                    this.sysPromptDiffTruncated = !!normalizedDiff.truncated;
+                    this.sysPromptDiffHasChangesValue = !!normalizedDiff.hasChanges;
+                    if (normalizedDiff.stats && typeof normalizedDiff.stats === 'object') {
+                        this.sysPromptDiffStats = {
+                            added: Number(normalizedDiff.stats.added || 0),
+                            removed: Number(normalizedDiff.stats.removed || 0),
+                            unchanged: Number(normalizedDiff.stats.unchanged || 0)
+                        };
+                    } else {
+                        const stats = { added: 0, removed: 0, unchanged: 0 };
+                        for (const line of this.sysPromptDiffLines) {
+                            if (line && line.type === 'add') stats.added += 1;
+                            else if (line && line.type === 'del') stats.removed += 1;
+                            else stats.unchanged += 1;
+                        }
+                        this.sysPromptDiffStats = stats;
+                    }
+                    this.sysPromptDiffFingerprint = requestFingerprint;
+                    return true;
+                };
+                const previewRequest = buildAgentsDiffPreviewRequest({
+                    baseContent: this.sysPromptOriginalContent,
+                    content: this.sysPromptContent,
+                    lineEnding: '\n',
+                    context: 'sys-prompt',
+                    baseDir: undefined
+                });
+                if (previewRequest.exceedsBodyLimit) {
+                    applyPreviewState(buildAgentsDiffPreview({
+                        baseContent: this.sysPromptOriginalContent,
+                        content: this.sysPromptContent
+                    }));
+                    return;
+                }
+                const rpcParams = {
+                    ...previewRequest.params,
+                    scope: this.sysPromptScope || 'global',
+                    mode: this.sysPromptMode || 'append'
+                };
+                const res = await apiWithMeta('preview-system-prompt-diff', rpcParams);
+                if (!shouldApplyPreviewState()) return;
+                if (res.error) {
+                    if (isAgentsDiffPreviewPayloadTooLarge(res)) {
+                        applyPreviewState(buildAgentsDiffPreview({
+                            baseContent: this.sysPromptOriginalContent,
+                            content: this.sysPromptContent
+                        }));
+                        return;
+                    }
+                    this.sysPromptDiffError = res.error;
+                    return;
+                }
+                applyPreviewState(res.diff);
+            } catch (e) {
+                if (shouldApplyAgentsDiffPreviewResponse({
+                    isVisible: this.sysPromptDiffVisible,
+                    requestToken,
+                    activeRequestToken: this._sysPromptDiffPreviewRequestToken,
+                    requestFingerprint,
+                    currentFingerprint: this.buildSysPromptDiffFingerprint()
+                })) {
+                    this.sysPromptDiffError = '生成差异失败';
+                }
+            } finally {
+                if (this._sysPromptDiffPreviewRequestToken === requestToken) {
+                    this.sysPromptDiffLoading = false;
+                }
+            }
+        },
+
+        cancelSysPromptEdit() {
+            if (this.sysPromptSaving || this.sysPromptDiffLoading) return;
+            this.resetSysPromptDiffState();
+            this.loadSystemPrompt();
+        },
+
+        async applySystemPrompt() {
+            if (this.sysPromptSaving) return;
+            if (!this.sysPromptDiffVisible) {
+                if (!this.hasSysPromptContentChanged()) {
+                    this.showMessage(this.t('toast.noChanges'), 'info');
+                    return;
+                }
+                await this.prepareSysPromptDiff();
+                return;
+            }
+            if (this.sysPromptDiffLoading) return;
+            if (this.sysPromptDiffError) {
+                this.showMessage(this.sysPromptDiffError, 'error');
+                return;
+            }
+            const fingerprint = this.buildSysPromptDiffFingerprint();
+            if (this.sysPromptDiffFingerprint !== fingerprint) {
+                await this.prepareSysPromptDiff();
+                return;
+            }
+            if (!this.sysPromptDiffHasChangesValue) {
+                this.showMessage(this.t('toast.noChanges'), 'info');
+                return;
+            }
+            this.sysPromptSaving = true;
+            try {
+                const params = {
+                    scope: this.sysPromptScope || 'global',
+                    mode: this.sysPromptMode || 'append',
+                    content: this.sysPromptContent,
+                    baseHash: this.sysPromptHash
+                };
+                const res = await api('apply-system-prompt', params);
+                if (res.error) {
+                    this.showMessage(res.error, 'error');
+                    return;
+                }
+                this.showMessage(this.t('sysPrompt.toast.saved'), 'success');
+                await this.loadSystemPrompt();
+            } catch (e) {
+                this.showMessage(this.t('toast.save.fail'), 'error');
+            } finally {
+                this.sysPromptSaving = false;
+            }
+        },
+
+        copySysPromptContent() {
+            const content = typeof this.sysPromptContent === 'string' ? this.sysPromptContent : '';
+            if (!content) return;
+            try {
+                navigator.clipboard?.writeText(content);
+                this.showMessage(this.t('common.copy'), 'success');
+            } catch (_) {}
+        },
+
+        exportSysPromptContent() {
+            const content = typeof this.sysPromptContent === 'string' ? this.sysPromptContent : '';
+            if (!content) return;
+            const filename = (this.sysPromptMode === 'system' ? 'SYSTEM.md' : 'APPEND_SYSTEM.md');
+            const blob = new Blob([content], { type: 'text/markdown' });
+            const a = document.createElement('a');
+            a.href = URL.createObjectURL(blob);
+            a.download = filename;
+            document.body.appendChild(a);
+            a.click();
+            a.remove();
+            URL.revokeObjectURL(a.href);
+        },
+
+        async pasteSysPromptContent() {
+            if (this.sysPromptLoading || this.sysPromptSaving || this.sysPromptDiffVisible) return;
+            try {
+                const text = await navigator.clipboard.readText();
+                if (text) {
+                    this.sysPromptContent = text;
+                    this.showMessage(this.t('common.paste'), 'success');
+                }
+            } catch (_) {}
+        },
+
+        sysPromptContextHint() {
+            if (!this.sysPromptLoading && !this.sysPromptDiffVisible && this.hasSysPromptContentChanged()) {
+                return { text: this.t('sysPrompt.hint.unsaved'), warn: true };
+            }
+            if (this.sysPromptDiffVisible && (this.sysPromptDiffLoading || this.sysPromptSaving)) {
+                return { text: this.t('diff.hint.busy'), warn: false };
+            }
+            if (this.sysPromptDiffVisible && this.sysPromptDiffError) {
+                return { text: this.t('diff.hint.failedBack'), warn: false };
+            }
+            if (this.sysPromptDiffVisible && !this.sysPromptDiffHasChangesValue) {
+                return { text: this.t('diff.hint.noChangesBack'), warn: false };
+            }
+            if (this.sysPromptDiffVisible && this.sysPromptDiffTruncated) {
+                return { text: this.t('diff.viewHint.truncated'), warn: false };
+            }
+            if (this.sysPromptDiffVisible) {
+                return { text: this.t('diff.viewHint.preview'), warn: false };
+            }
+            if (!this.sysPromptLoading) {
+                return { text: this.t('sysPrompt.hint.twoStepSave'), warn: false };
+            }
+            return null;
+        }
+    };
+}