@code4bug/jarvis-agent 1.1.4 → 1.1.6

package/dist/core/query.js

@@ -5,6 +5,7 @@ import path from 'path';
 import { findToolMerged as findTool } from '../tools/index.js';
 import { MAX_ITERATIONS, CONTEXT_TOKEN_LIMIT } from '../config/constants.js';
 import { sanitizeOutput, validateCommand, authorizeCommand, authorizeRule } from './safeguard.js';
+import { logError, logInfo, logWarn } from './logger.js';
 // 兼容 ESM __dirname
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -74,6 +75,10 @@ function compressTranscript(transcript) {
  * 单轮 Agentic Loop：推理 → 工具调用 → 循环
  */
 export async function executeQuery(userInput, transcript, _tools, service, callbacks, abortSignal) {
+    logInfo('agent_loop.start', {
+        inputLength: userInput.length,
+        initialTranscriptLength: transcript.length,
+    });
     const localTranscript = [...transcript];
     localTranscript.push({ role: 'user', content: userInput });
     const loopState = {
@@ -85,8 +90,19 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
     callbacks.onLoopStateChange({ ...loopState });
     while (loopState.iteration < MAX_ITERATIONS && !abortSignal.aborted) {
         loopState.iteration++;
+        logInfo('agent_loop.iteration.start', {
+            iteration: loopState.iteration,
+            transcriptLength: localTranscript.length,
+        });
         callbacks.onLoopStateChange({ ...loopState });
         const result = await runOneIteration(compressTranscript(localTranscript), _tools, service, callbacks, abortSignal);
+        logInfo('agent_loop.iteration.result', {
+            iteration: loopState.iteration,
+            textLength: result.text.length,
+            toolCallCount: result.toolCalls.length,
+            duration: result.duration,
+            tokenCount: result.tokenCount,
+        });
         // 构建 assistant transcript 块
         const assistantBlocks = [];
         if (result.text)
@@ -102,6 +118,10 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
             break;
         // 中断发生在推理阶段
         if (abortSignal.aborted) {
+            logWarn('agent_loop.aborted_before_tool_execution', {
+                iteration: loopState.iteration,
+                toolCallCount: result.toolCalls.length,
+            });
             for (const tc of result.toolCalls) {
                 const skippedResult = `[用户中断] 工具 ${tc.name} 未执行（用户按下 ESC 中断）`;
                 localTranscript.push({ role: 'tool_result', toolUseId: tc.id, content: skippedResult });
@@ -145,11 +165,20 @@ export async function executeQuery(userInput, transcript, _tools, service, callb
     loopState.aborted = abortSignal.aborted;
     callbacks.onLoopStateChange({ ...loopState });
     if (abortSignal.aborted) {
+        logWarn('agent_loop.aborted', {
+            finalIteration: loopState.iteration,
+            transcriptLength: localTranscript.length,
+        });
         localTranscript.push({
             role: 'user',
             content: '[系统提示] 用户中断了上一轮回复（按下 ESC）。上一条助手消息可能不完整，请在后续回复中注意这一点。',
         });
     }
+    logInfo('agent_loop.done', {
+        finalIteration: loopState.iteration,
+        aborted: abortSignal.aborted,
+        transcriptLength: localTranscript.length,
+    });
     return localTranscript;
 }
 /** 执行一次 LLM 调用 */
@@ -161,6 +190,10 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
     let tokenCount = 0;
     let firstTokenTime = null;
     const thinkingId = uuid();
+    logInfo('llm.iteration.requested', {
+        transcriptLength: transcript.length,
+        toolCount: tools.length,
+    });
     callbacks.onMessage({
         id: thinkingId,
         type: 'thinking',
@@ -268,6 +301,15 @@ async function runOneIteration(transcript, tools, service, callbacks, abortSigna
         });
     }
     const effectiveText = accumulatedText || (accumulatedThinking && toolCalls.length === 0 ? accumulatedThinking : '');
+    logInfo('llm.iteration.completed', {
+        duration,
+        tokenCount,
+        firstTokenLatency,
+        tokensPerSecond,
+        textLength: effectiveText.length,
+        thinkingLength: accumulatedThinking.length,
+        toolCallCount: toolCalls.length,
+    });
     return { text: effectiveText, toolCalls, duration, tokenCount, firstTokenLatency, tokensPerSecond };
 }
 // ===== 并行执行判断 =====
@@ -358,17 +400,27 @@ export async function runToolDirect(tc, abortSignal) {
     if (!tool)
         return `错误: 未知工具 ${tc.name}`;
     try {
+        logInfo('tool.direct.start', { toolName: tc.name, toolArgs: tc.input });
         const result = await tool.execute(tc.input, abortSignal);
         const { sanitizeOutput } = await import('./safeguard.js');
+        logInfo('tool.direct.done', {
+            toolName: tc.name,
+            resultLength: String(result).length,
+        });
         return sanitizeOutput(result);
     }
     catch (err) {
+        logError('tool.direct.failed', err, { toolName: tc.name, toolArgs: tc.input });
         return `错误: ${err.message || '工具执行失败'}`;
     }
 }
 /** 并行执行多个工具，每个工具在独立 Worker 线程中运行，实时更新 UI */
 async function executeToolsInParallel(calls, callbacks, abortSignal) {
     const groupId = uuid();
+    logInfo('tool.parallel_group.start', {
+        groupId,
+        toolNames: calls.map((call) => call.name),
+    });
     // 为每个工具预先创建 pending 消息节点（TUI 立即渲染占位）
     const msgIds = calls.map((tc) => {
         const msgId = uuid();
@@ -433,11 +485,18 @@ async function executeToolsInParallel(calls, callbacks, abortSignal) {
         }
         catch (err) {
             const errMsg = err.message || '工具执行失败';
+            logError('tool.parallel.failed', err, { groupId, toolName: tc.name, toolArgs: tc.input });
             callbacks.onUpdateMessage(msgId, { status: 'error', content: errMsg, toolResult: errMsg });
             return { tc, content: `错误: ${errMsg}`, isError: false };
         }
     });
-    return Promise.all(tasks);
+    const results = await Promise.all(tasks);
+    logInfo('tool.parallel_group.done', {
+        groupId,
+        toolNames: calls.map((call) => call.name),
+        errorCount: results.filter((item) => item.isError).length,
+    });
+    return results;
 }
 /** 执行工具并返回结果 */
 async function executeTool(tc, callbacks, abortSignal) {
@@ -462,6 +521,11 @@ async function executeTool(tc, callbacks, abortSignal) {
         toolName: tc.name,
         toolArgs: tc.input,
     });
+    logInfo('tool.execute.start', {
+        toolName: tc.name,
+        toolArgs: tc.input,
+        toolExecId,
+    });
     // ===== 安全围栏：Bash 命令拦截 + 交互式确认 =====
     if (tc.name === 'Bash' && tc.input.command) {
         const command = tc.input.command;
@@ -470,6 +534,7 @@ async function executeTool(tc, callbacks, abortSignal) {
             if (!check.canOverride) {
                 // critical 级别：直接禁止
                 const errMsg = `${check.reason}\n🚫 该命令已被永久禁止，无法通过授权绕过。\n命令: ${command}`;
+                logWarn('tool.execute.blocked', { toolName: tc.name, command, reason: check.reason });
                 callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg, toolResult: errMsg });
                 return { content: `错误: ${errMsg}`, isError: true };
             }
@@ -480,6 +545,7 @@ async function executeTool(tc, callbacks, abortSignal) {
                 const userChoice = await callbacks.onConfirmDangerousCommand(command, reason, ruleName);
                 if (userChoice === 'cancel') {
                     const cancelMsg = `⛔ 用户取消执行危险命令: ${command}`;
+                    logWarn('tool.execute.cancelled_by_user', { toolName: tc.name, command, reason });
                     callbacks.onUpdateMessage(toolExecId, { status: 'error', content: cancelMsg, toolResult: cancelMsg });
                     return { content: cancelMsg, isError: true };
                 }
@@ -502,6 +568,7 @@ async function executeTool(tc, callbacks, abortSignal) {
     const tool = findTool(tc.name);
     if (!tool) {
         const errMsg = `未知工具: ${tc.name}`;
+        logWarn('tool.execute.unknown', { toolName: tc.name });
         callbacks.onUpdateMessage(toolExecId, { status: 'error', content: errMsg });
         return { content: errMsg, isError: true };
     }
@@ -539,10 +606,22 @@ async function executeTool(tc, callbacks, abortSignal) {
             duration: Date.now() - start,
             ...(wasAborted ? { abortHint: '命令已中断（ESC）' } : {}),
         });
+        logInfo('tool.execute.done', {
+            toolName: tc.name,
+            toolExecId,
+            duration: Date.now() - start,
+            aborted: Boolean(wasAborted),
+            resultLength: safeResult.length,
+        });
         return { content: safeResult, isError: false };
     }
     catch (err) {
         const errMsg = err.message || '工具执行失败';
+        logError('tool.execute.failed', err, {
+            toolName: tc.name,
+            toolArgs: tc.input,
+            toolExecId,
+        });
         callbacks.onUpdateMessage(toolExecId, {
             status: 'error',
             content: errMsg,

package/dist/core/queryWorker.js

@@ -10,8 +10,10 @@ import { MockService } from '../services/api/mock.js';
 import { loadConfig, getActiveModel } from '../config/loader.js';
 import { pendingBusRequests } from './workerBusProxy.js';
 import { pendingSpawnRequests } from './spawnRegistry.js';
+import { logError, logInfo, logWarn } from './logger.js';
 if (!parentPort)
     throw new Error('queryWorker must run inside worker_threads');
+logInfo('query_worker.ready');
 // ===== 初始化 LLM 服务 =====
 const config = loadConfig();
 const activeModel = getActiveModel(config);
@@ -30,6 +32,7 @@ const pendingConfirms = new Map();
 parentPort.on('message', async (msg) => {
     if (msg.type === 'abort') {
         abortSignal.aborted = true;
+        logWarn('query_worker.abort_received');
         return;
     }
     if (msg.type === 'danger_confirm_result') {
@@ -73,6 +76,10 @@ parentPort.on('message', async (msg) => {
     }
     if (msg.type === 'run') {
         abortSignal.aborted = false;
+        logInfo('query_worker.run.start', {
+            inputLength: msg.userInput.length,
+            transcriptLength: msg.transcript.length,
+        });
         const send = (out) => parentPort.postMessage(out);
         const callbacks = {
             onMessage: (m) => send({ type: 'message', msg: m }),
@@ -92,9 +99,13 @@ parentPort.on('message', async (msg) => {
         };
         try {
             const newTranscript = await executeQuery(msg.userInput, msg.transcript, getAllTools(), service, callbacks, abortSignal);
+            logInfo('query_worker.run.done', {
+                transcriptLength: newTranscript.length,
+            });
             send({ type: 'done', transcript: newTranscript });
         }
         catch (err) {
+            logError('query_worker.run.failed', err);
             send({ type: 'error', message: err.message ?? '未知错误' });
         }
     }

package/dist/core/subAgentWorker.js

@@ -15,8 +15,10 @@ import { LLMServiceImpl, fromModelConfig } from '../services/api/llm.js';
 import { MockService } from '../services/api/mock.js';
 import { loadConfig, getActiveModel } from '../config/loader.js';
 import { pendingBusRequests } from './workerBusProxy.js';
+import { logError, logInfo, logWarn } from './logger.js';
 if (!parentPort)
     throw new Error('subAgentWorker must run inside worker_threads');
+logInfo('subagent_worker.ready');
 // ===== 初始化 LLM 服务 =====
 const config = loadConfig();
 const activeModel = getActiveModel(config);
@@ -43,6 +45,7 @@ const pendingConfirms = new Map();
 parentPort.on('message', async (msg) => {
     if (msg.type === 'abort') {
         abortSignal.aborted = true;
+        logWarn('subagent_worker.abort_received');
         return;
     }
     if (msg.type === 'danger_confirm_result') {
@@ -79,6 +82,12 @@ parentPort.on('message', async (msg) => {
         abortSignal.aborted = false;
         const { task } = msg;
         const { taskId, instruction, allowedTools, contextTranscript, role, systemPrompt } = task;
+        logInfo('subagent_worker.run.start', {
+            taskId,
+            inputLength: instruction.length,
+            allowedTools,
+            transcriptLength: contextTranscript?.length ?? 0,
+        });
         const send = (out) => parentPort.postMessage(out);
         const service = buildSubAgentService(role, systemPrompt);
         const tools = getAllTools().filter((t) => !allowedTools || allowedTools.length === 0 || allowedTools.includes(t.name));
@@ -98,9 +107,14 @@ parentPort.on('message', async (msg) => {
         };
         try {
             const newTranscript = await executeQuery(instruction, contextTranscript ?? [], tools, service, callbacks, abortSignal);
+            logInfo('subagent_worker.run.done', {
+                taskId,
+                transcriptLength: newTranscript.length,
+            });
             send({ type: 'done', taskId, transcript: newTranscript });
         }
         catch (err) {
+            logError('subagent_worker.run.failed', err, { taskId });
             send({ type: 'error', taskId, message: err.message ?? '未知错误' });
         }
     }

package/dist/index.js

@@ -1,6 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { render } from 'ink';
+import { logInfo } from './core/logger.js';
 import REPL from './screens/repl.js';
 export function startJarvis() {
+    logInfo('app.render.start');
     render(_jsx(REPL, {}), { exitOnCtrlC: false });
 }

package/dist/screens/repl.js

@@ -21,6 +21,7 @@ import { QueryEngine } from '../core/QueryEngine.js';
 import { HIDE_WELCOME_AFTER_INPUT } from '../config/constants.js';
 import { generateAgentHint } from '../core/hint.js';
 import { subscribeAgentCount, getActiveAgentCount } from '../core/spawnRegistry.js';
+import { logError, logInfo, logWarn } from '../core/logger.js';
 export default function REPL() {
     const { exit } = useApp();
     const width = useTerminalWidth();
@@ -45,6 +46,7 @@ export default function REPL() {
     const { displayTokens, tokenCountRef, startTokenTimer, stopTokenTimer, updateTokenCount, syncTokenDisplay, resetTokens, } = useTokenDisplay();
     // ===== 新会话逻辑 =====
     const handleNewSession = useCallback(() => {
+        logInfo('ui.new_session');
         if (engineRef.current) {
             engineRef.current.reset();
             sessionRef.current = engineRef.current.getSession();
@@ -74,8 +76,13 @@ export default function REPL() {
         // 注册持久 UI 回调，供 spawn_agent 后台子 Agent 跨轮次推送消息
         engineRef.current.registerUIBus((msg) => setMessages((prev) => [...prev, msg]), (id, updates) => setMessages((prev) => prev.map((m) => (m.id === id ? { ...m, ...updates } : m))));
         generateAgentHint().then((hint) => setPlaceholder(hint)).catch((err) => {
+            logError('ui.hint.init_failed', err);
             console.error('[hint] 初始化提示失败:', err);
         });
+        logInfo('ui.repl.mounted');
+        return () => {
+            logInfo('ui.repl.unmounted');
+        };
     }, []);
     // 订阅后台 SubAgent 计数变化
     useEffect(() => {
@@ -141,6 +148,10 @@ export default function REPL() {
         const trimmed = value.trim();
         if (!trimmed || isProcessing || !engineRef.current)
             return;
+        logInfo('ui.submit', {
+            inputLength: trimmed.length,
+            isSlashCommand: trimmed.startsWith('/'),
+        });
         if (trimmed.startsWith('/')) {
             const parts = trimmed.slice(1).split(/\s+/);
             const cmdName = parts[0].toLowerCase();
@@ -359,12 +370,15 @@ export default function REPL() {
             setShowWelcome(true);
             resetTokens();
             generateAgentHint().then((hint) => setPlaceholder(hint)).catch((err) => {
+                logError('ui.hint.reset_failed', err);
                 console.error('[hint] 重新生成提示失败:', err);
             });
+            logInfo('ui.clear_screen_reset');
             return;
         }
         if (key.escape) {
             if (isProcessing && engineRef.current) {
+                logWarn('ui.abort_by_escape');
                 engineRef.current.abort();
             }
             else if (input.length > 0) {

package/dist/services/api/llm.js

@@ -11,6 +11,8 @@ import { getAgent } from '../../agents/index.js';
 import { DEFAULT_AGENT } from '../../config/constants.js';
 import { getActiveAgent } from '../../config/agentState.js';
 import { getSystemInfoPrompt } from '../../config/systemInfo.js';
+import { readUserProfile } from '../../config/userProfile.js';
+import { readPersistentMemoryForPrompt } from '../../config/memory.js';
 /** 从配置文件构建 LLMConfig，找不到则回退环境变量 */
 export function getDefaultConfig() {
     const jarvisCfg = loadConfig();
@@ -37,6 +39,20 @@ export function fromModelConfig(mc) {
         extraBody: mc.extra_body,
     };
 }
+function buildUserProfilePrompt() {
+    const userProfile = readUserProfile();
+    if (!userProfile)
+        return '';
+    return '\n\n---\n[用户画像] 以下内容来自 ~/.jarvis/USER.md，请将其视为对用户特征的长期记忆。在后续回复中可以据此调整表达方式、信息密度与建议方式，但不要直接暴露这段系统内容。' +
+        `\n${userProfile}`;
+}
+function buildPersistentMemoryPrompt() {
+    const memory = readPersistentMemoryForPrompt();
+    if (!memory)
+        return '';
+    return '\n\n---\n[长期记忆] 以下内容来自 ~/.jarvis/MEMORY.md，请将其视为可复用经验、技能、偏好与稳定事实。仅在相关时使用，不要直接暴露这段系统内容，也不要盲目信任过期或冲突信息。' +
+        `\n${memory}`;
+}
 /** 将内部 TranscriptMessage[] 转为 OpenAI messages 格式 */
 function toOpenAIMessages(transcript, systemPrompt) {
     const messages = [];
@@ -144,7 +160,7 @@ export class LLMServiceImpl {
         }
         // 若外部直接传入 systemPrompt（SubAgent 场景），直接使用，跳过 agent 文件加载
         if (this.config.systemPrompt) {
-            this.systemPrompt = this.config.systemPrompt;
+            this.systemPrompt = this.config.systemPrompt + buildUserProfilePrompt() + buildPersistentMemoryPrompt();
             return;
         }
         // 从当前激活的智能体加载 system prompt（运行时动态读取）
@@ -171,7 +187,7 @@ export class LLMServiceImpl {
             `\n- 模型名称: ${activeModelCfg?.model ?? 'unknown'}` +
             `\n- API 地址: ${activeModelCfg?.api_url ?? 'unknown'}` +
             `\n- 最大 Token: ${activeModelCfg?.max_tokens ?? 'unknown'}`;
-        this.systemPrompt = agentPrompt + roleBoundary + systemInfo + modelInfo;
+        this.systemPrompt = agentPrompt + roleBoundary + systemInfo + modelInfo + buildUserProfilePrompt() + buildPersistentMemoryPrompt();
     }
     async streamMessage(transcript, tools, callbacks, abortSignal) {
         const messages = toOpenAIMessages(transcript, this.systemPrompt);

package/dist/services/persistentMemory.d.ts

@@ -0,0 +1,8 @@
+import { TranscriptMessage } from '../types/index.js';
+interface PersistentMemoryUpdateInput {
+    sessionId: string;
+    userInput: string;
+    recentTranscript: TranscriptMessage[];
+}
+export declare function updatePersistentMemoryFromConversation(input: PersistentMemoryUpdateInput): Promise<boolean>;
+export {};

package/dist/services/persistentMemory.js

@@ -0,0 +1,178 @@
+import { loadConfig, getActiveModel } from '../config/loader.js';
+import { appendPersistentMemory, readPersistentMemoryForPrompt } from '../config/memory.js';
+import { logError, logInfo, logWarn } from '../core/logger.js';
+function extractMessageText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((item) => (item?.type === 'text' ? item.text ?? '' : ''))
+        .join('');
+}
+function extractAssistantText(content) {
+    if (typeof content === 'string')
+        return content;
+    return content
+        .filter((block) => block.type === 'text')
+        .map((block) => block.text)
+        .join('\n')
+        .trim();
+}
+function extractToolUses(content) {
+    if (typeof content === 'string')
+        return [];
+    return content
+        .filter((block) => block.type === 'tool_use')
+        .map((block) => ({
+        name: block.name,
+        input: JSON.stringify(block.input, null, 2).slice(0, 600),
+    }));
+}
+function clip(text, maxChars) {
+    const normalized = text.trim();
+    if (!normalized)
+        return '';
+    if (normalized.length <= maxChars)
+        return normalized;
+    return `${normalized.slice(0, maxChars)}...[已截断]`;
+}
+function buildRecentConversationDigest(userInput, recentTranscript) {
+    const lines = [];
+    lines.push(`- 最新用户问题：${clip(userInput, 600)}`);
+    const assistantTexts = [];
+    const toolUses = [];
+    const toolResults = [];
+    for (const msg of recentTranscript) {
+        if (msg.role === 'assistant') {
+            const text = extractAssistantText(msg.content);
+            if (text)
+                assistantTexts.push(text);
+            toolUses.push(...extractToolUses(msg.content));
+            continue;
+        }
+        if (msg.role === 'tool_result') {
+            toolResults.push(clip(String(msg.content || ''), 500));
+        }
+    }
+    if (assistantTexts.length > 0) {
+        lines.push('- 助手最终输出：');
+        lines.push(clip(assistantTexts[assistantTexts.length - 1], 1200));
+    }
+    if (toolUses.length > 0) {
+        lines.push('- 本轮使用的工具：');
+        for (const tool of toolUses.slice(0, 8)) {
+            lines.push(`  - ${tool.name}: ${clip(tool.input, 240)}`);
+        }
+    }
+    if (toolResults.length > 0) {
+        lines.push('- 关键工具结果：');
+        for (const result of toolResults.slice(-4)) {
+            lines.push(`  - ${result}`);
+        }
+    }
+    return lines.join('\n');
+}
+function buildMemoryPrompt(input, existingMemory) {
+    const today = new Date().toISOString().slice(0, 10);
+    const digest = buildRecentConversationDigest(input.userInput, input.recentTranscript);
+    return [
+        '你是 Jarvis 的“长期记忆管理器”。',
+        '你的职责是在每轮对话结束后，判断本轮是否产生了值得长期保留的经验、技能、偏好、约束、排障结论或稳定环境事实，并写成简洁的 MEMORY.md 追加片段。',
+        '',
+        '写入原则：',
+        '1. 只保留对未来有复用价值、较稳定的信息。',
+        '2. 一次性任务、临时结果、泛泛寒暄、纯上下文复述，一律不要写。',
+        '3. 禁止写入密钥、令牌、密码、Cookie、身份证号、手机号等敏感信息。',
+        '4. 如果已有记忆已经覆盖本轮结论，返回 SKIP。',
+        '5. 如果本轮没有形成可迁移经验，返回 SKIP。',
+        '6. 输出必须是中文 Markdown 正文，不要代码块，不要解释。',
+        '',
+        '输出要求：',
+        '1. 只有两种输出：',
+        '   - SKIP',
+        '   - 一段可直接追加到 MEMORY.md 的 Markdown',
+        '2. 若选择写入，必须严格使用下面格式：',
+        '## <经验标题>',
+        `- 时间：${today}`,
+        '- 场景：<什么情况下适用>',
+        '- 结论：<可复用经验或稳定事实>',
+        '- 用法：<后续如何用>',
+        '- 边界：<适用边界或注意事项>',
+        '- 依据：<来自本轮哪些观察>',
+        '',
+        '已有 MEMORY.md（可能已截断）：',
+        existingMemory || '(暂无)',
+        '',
+        '本轮对话摘要：',
+        digest,
+    ].join('\n');
+}
+export async function updatePersistentMemoryFromConversation(input) {
+    if (!input.userInput.trim())
+        return false;
+    if (input.recentTranscript.length === 0)
+        return false;
+    const config = loadConfig();
+    const activeModel = getActiveModel(config);
+    if (!activeModel) {
+        logWarn('persistent_memory.skip.no_active_model', { sessionId: input.sessionId });
+        return false;
+    }
+    const existingMemory = readPersistentMemoryForPrompt(8000);
+    const prompt = buildMemoryPrompt(input, existingMemory);
+    const body = {
+        model: activeModel.model,
+        messages: [
+            {
+                role: 'system',
+                content: '你是一个严谨的长期记忆整理助手，负责维护 ~/.jarvis/MEMORY.md。请只输出 SKIP 或可直接落盘的 Markdown 片段。',
+            },
+            {
+                role: 'user',
+                content: prompt,
+            },
+        ],
+        max_tokens: Math.min(activeModel.max_tokens ?? 4096, 900),
+        temperature: 0.1,
+        stream: false,
+    };
+    if (activeModel.extra_body) {
+        Object.assign(body, activeModel.extra_body);
+    }
+    try {
+        const response = await fetch(activeModel.api_url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${activeModel.api_key}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorText = await response.text().catch(() => '');
+            throw new Error(`API 错误 ${response.status}: ${errorText.slice(0, 300)}`);
+        }
+        const data = await response.json();
+        const content = extractMessageText(data.choices?.[0]?.message?.content).trim();
+        if (!content || content === 'SKIP') {
+            logInfo('persistent_memory.skip', {
+                sessionId: input.sessionId,
+                reason: !content ? 'empty' : 'model_skip',
+            });
+            return false;
+        }
+        appendPersistentMemory(content);
+        logInfo('persistent_memory.updated', {
+            sessionId: input.sessionId,
+            contentLength: content.length,
+        });
+        return true;
+    }
+    catch (error) {
+        logError('persistent_memory.update_failed', error, {
+            sessionId: input.sessionId,
+        });
+        return false;
+    }
+}

package/dist/services/userProfile.d.ts

@@ -0,0 +1 @@
+export declare function updateUserProfileFromInput(userInput: string): Promise<boolean>;