@xcanwin/manyoyo 7.0.18 → 7.0.21

package/lib/web/server.js

@@ -30,82 +30,7 @@ const {
     projectSessionEvents
 } = require('../core/events');
 const { FileEventStore } = require('../core/event-store');
-const { buildManyoyoLogPath, getLocalDateTag } = require('../log-path'); // DIAG_LOG
 
-// DIAG_LOG BEGIN：临时详细诊断日志基础设施，用于排查 serve 接口超时 / agent
-// 流式回复长时间卡在"…"不实时更新的问题。排查结束后可整体删除：全局搜索
-// "DIAG_LOG" 能定位到全部相关代码（这段辅助函数、各处打点调用、下方
-// /api/diag/logs 接口、/logs 页面路由），一并删掉不影响其它功能。
-const DIAG_LOG_LINE_PATTERN = /^\[([^\]]+)\] \[pid:(\d+)\] \[(\w+)\] \[DIAG_LOG\] (\S+)(?: ([\s\S]*))?$/;
-
-function diagLog(ctx, category, extra = {}) {
-    if (!ctx || !ctx.logger || typeof ctx.logger.info !== 'function') {
-        return;
-    }
-    ctx.logger.info(`[DIAG_LOG] ${String(category || '')}`, extra);
-}
-
-function parseDiagLogLine(line) {
-    const matched = String(line || '').match(DIAG_LOG_LINE_PATTERN);
-    if (!matched) {
-        return null;
-    }
-    let extra = {};
-    if (matched[5]) {
-        try {
-            extra = JSON.parse(matched[5]);
-        } catch (e) {
-            extra = { raw: matched[5] };
-        }
-    }
-    return {
-        ts: matched[1],
-        pid: Number(matched[2]),
-        level: matched[3],
-        category: matched[4],
-        extra
-    };
-}
-
-function diagLogDir(ctx) {
-    if (ctx && ctx.logger && typeof ctx.logger.path === 'string' && ctx.logger.path) {
-        return path.dirname(ctx.logger.path);
-    }
-    return buildManyoyoLogPath('serve').dir;
-}
-
-function readDiagLogEntries(ctx, options = {}) {
-    const dateTag = options.date ? String(options.date) : getLocalDateTag();
-    const filePath = path.join(diagLogDir(ctx), `serve-${dateTag}.log`);
-    if (!fs.existsSync(filePath)) {
-        return [];
-    }
-    const limit = Number.isInteger(options.limit) && options.limit > 0 ? Math.min(options.limit, 2000) : 500;
-    const category = options.category ? String(options.category) : '';
-    const session = options.session ? String(options.session) : '';
-    const keyword = options.keyword ? String(options.keyword).toLowerCase() : '';
-
-    const lines = fs.readFileSync(filePath, 'utf-8').split('\n');
-    const entries = [];
-    for (const line of lines) {
-        const entry = parseDiagLogLine(line);
-        if (!entry) {
-            continue;
-        }
-        if (category && entry.category !== category) {
-            continue;
-        }
-        if (session && entry.extra.session !== session) {
-            continue;
-        }
-        if (keyword && !line.toLowerCase().includes(keyword)) {
-            continue;
-        }
-        entries.push(entry);
-    }
-    return entries.slice(-limit);
-}
-// DIAG_LOG END（下方还有零散打点调用与 /api/diag/logs、/logs 路由，同样标记为 DIAG_LOG）
 
 const WEB_HISTORY_MAX_MESSAGES = 500;
 const WEB_OUTPUT_MAX_CHARS = 16000;
@@ -138,6 +63,11 @@ const WEB_SESSION_KEY_SEPARATOR = '~';
 const WEB_DEFAULT_AGENT_ID = 'default';
 const WEB_DEFAULT_AGENT_NAME = 'AGENT 1';
 const WEB_CONFIG_KEEP_SECRET_PLACEHOLDER = '***HIDDEN_SECRET***';
+// 取 15s 是为了在 nginx proxy_read_timeout 默认 60s 下留足余量（即便某次心跳
+// 因事件循环繁忙被推迟，也还有三次机会），同时不至于把 NDJSON 流刷得太碎
+const DEFAULT_AGENT_STREAM_HEARTBEAT_MS = 15 * 1000;
+// token 级增量的历史落盘节流：写盘只为断线/刷新后能对账恢复，不需要逐 token 持久化
+const AGENT_STREAM_PARTIAL_PERSIST_INTERVAL_MS = 1000;
 const FRONTEND_DIR = path.join(__dirname, 'frontend');
 const SAFE_CONTAINER_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 const IMAGE_VERSION_TAG_PATTERN = /^(\d+\.\d+\.\d+)-([A-Za-z0-9][A-Za-z0-9_.-]*)$/;
@@ -462,9 +392,10 @@ function removeContainerIdempotent(ctx, containerName) {
     }
 }
 
-function removeAllAgentHistoryArtifacts(state, containerName, agentIds) {
+function removeAllAgentHistoryArtifacts(webHistoryDir, containerName, agentIds) {
+    const eventStore = new FileEventStore(webHistoryDir);
     (Array.isArray(agentIds) ? agentIds : []).forEach(agentId => {
-        state.eventStore.remove(buildWebSessionKey(containerName, agentId));
+        eventStore.remove(buildWebSessionKey(containerName, agentId));
     });
 }
 
@@ -622,57 +553,29 @@ function appendWebSessionMessage(webHistoryDir, sessionRefOrContainerName, role,
     return message;
 }
 
-// 流式过程中高频出现的"透传"控制事件类型（见 resolveWebStreamControlEventType）：
-// 每个 content_delta/trace 事件都会各自触发一次，量随回合长度线性增长。会话
-// 生命周期事件（session.ready/stopping/process.exited 等）不在其中，必须每次
-// 都立即落盘。
-const NOISY_CONTROL_EVENT_TYPES = new Set(['process.stdout', 'agent.turn.delta', 'agent.tool.observed']);
-const LIVE_HISTORY_FLUSH_INTERVAL_MS = 400;
-
-// 中间态历史落盘节流：同一 aggregateId 在节流窗口内只允许成功落盘一次，供
-// appendWebSessionControlEvent（events 镜像）与 /agent/stream 路由里的
-// patchWebSessionMessage（trace/content_delta 消息内容）共用同一个"落盘配额"，
-// 避免同一个事件被两条独立写路径各自整份重写一次 demo.json。节流只影响"实时
-// 进度对轮询标签页可见的时机"，不影响最终数据——两条写路径在回合结束/出错时
-// 都还有一次不受节流影响的完整落盘。
-function shouldFlushLiveHistory(state, aggregateId) {
-    const now = Date.now();
-    const lastFlushAt = state._liveHistoryFlushThrottle.get(aggregateId) || 0;
-    if (now - lastFlushAt < LIVE_HISTORY_FLUSH_INTERVAL_MS) {
-        return false;
-    }
-    state._liveHistoryFlushThrottle.set(aggregateId, now);
-    return true;
-}
-
-function appendWebSessionControlEvent(state, sessionRef, type, data = {}) {
-    const aggregateId = buildWebSessionKey(sessionRef.containerName, sessionRef.agentId);
-    // seq 必须以 state.eventStore 的内存缓存为准（而不是下面 agentSession.events
-    // 这份可能因落盘节流而滞后的历史 JSON 副本），否则节流生效时算出来的 seq
-    // 会与 eventStore 实际的 lastSeq 对不上，append() 会因"seq 必须连续递增"报错。
+function appendWebSessionControlEvent(webHistoryDir, sessionRef, type, data = {}) {
+    const history = loadWebSessionHistory(webHistoryDir, sessionRef.containerName);
+    const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true, includeArchived: true });
+    const events = Array.isArray(agentSession.events) ? agentSession.events : [];
+    const lastEvent = events.length ? events[events.length - 1] : null;
     const event = createControlEvent({
         type,
-        aggregateId,
-        seq: state.eventStore.getNextSeq(aggregateId),
+        aggregateId: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
+        seq: lastEvent ? lastEvent.seq + 1 : 1,
         data
     });
-    state.eventStore.append(event);
-
-    const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
-    const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true, includeArchived: true });
-    const events = Array.isArray(agentSession.events) ? agentSession.events : [];
+    const eventStore = new FileEventStore(webHistoryDir);
+    eventStore.append(event);
     agentSession.events = [...events, event].slice(-WEB_HISTORY_MAX_MESSAGES);
     agentSession.updatedAt = event.timestamp;
     history.updatedAt = event.timestamp;
-    if (!NOISY_CONTROL_EVENT_TYPES.has(type) || shouldFlushLiveHistory(state, aggregateId)) {
-        saveWebSessionHistory(state.webHistoryDir, sessionRef.containerName, history);
-    }
+    saveWebSessionHistory(webHistoryDir, sessionRef.containerName, history);
     return event;
 }
 
-function loadWebSessionControlEvents(state, sessionRef, fallbackEvents = []) {
+function loadWebSessionControlEvents(webHistoryDir, sessionRef, fallbackEvents = []) {
     try {
-        const events = state.eventStore.read(
+        const events = new FileEventStore(webHistoryDir).read(
             buildWebSessionKey(sessionRef.containerName, sessionRef.agentId)
         );
         if (events.length) {
@@ -957,7 +860,12 @@ function buildClaudeAgentExecCommand(template, prompt, options = {}) {
     const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
     const flagSpecs = [
         { flag: '--verbose', pattern: /(?:^|\s)--verbose(?:\s|$)/ },
-        { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ }
+        { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ },
+        // 没有这个 flag 时 claude 只在整条 assistant 消息生成完之后才吐一行 JSON：
+        // 一段几千字的回答会静默几十秒再一次性刷出来，用户看到的"执行过程"是分批跳变的。
+        // 带上之后会额外输出 stream_event/content_block_delta 的 token 级增量
+        //（解析见 extractContentDeltaFromPayload）
+        { flag: '--include-partial-messages', pattern: /(?:^|\s)--include-partial-messages(?:\s|$)/ }
     ];
     const sessionId = options && typeof options.sessionId === 'string' ? options.sessionId.trim() : '';
     if (sessionId) {
@@ -1819,12 +1727,39 @@ function prepareStructuredTraceEvents(agentProgram, payload, state) {
     return [];
 }
 
-function extractContentDeltaFromPayload(agentProgram, payload) {
+function extractContentDeltaFromPayload(agentProgram, payload, state = {}) {
     if (!payload || typeof payload !== 'object') {
         return null;
     }
     if (agentProgram === 'claude') {
-        if (pickFirstString(payload.type) !== 'assistant') {
+        const payloadType = pickFirstString(payload.type);
+        // --include-partial-messages 产生的 token 级增量。text 是累计全文（服务端
+        // 落盘用），chunk 是本次新增的片段（下发给前端用）——一轮回答可能有几千个
+        // 增量，每次都把累计全文发一遍是 O(n²) 流量，长回答能到 MB 级。
+        // 一轮里可能有多条 assistant 消息（正文→工具→正文），message_start 清空累计，
+        // 语义与下面整条 assistant 消息的 reset 一致
+        if (payloadType === 'stream_event') {
+            const streamEvent = toPlainObject(payload.event);
+            const streamEventType = pickFirstString(streamEvent.type);
+            if (streamEventType === 'message_start') {
+                state.claudePartialText = '';
+                return { text: '', reset: true, partial: true, chunk: '', chunkReset: true };
+            }
+            if (streamEventType !== 'content_block_delta') {
+                return null;
+            }
+            const delta = toPlainObject(streamEvent.delta);
+            if (pickFirstString(delta.type) !== 'text_delta') {
+                return null;
+            }
+            const deltaText = typeof delta.text === 'string' ? delta.text : '';
+            if (!deltaText) {
+                return null;
+            }
+            state.claudePartialText = `${state.claudePartialText || ''}${deltaText}`;
+            return { text: state.claudePartialText, reset: true, partial: true, chunk: deltaText };
+        }
+        if (payloadType !== 'assistant') {
             return null;
         }
         const message = toPlainObject(payload.message);
@@ -2096,7 +2031,7 @@ function prepareCodexTraceEvent(payload) {
 async function prepareWebAgentExecution(ctx, state, sessionRef, prompt) {
     const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
     const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true, includeArchived: true });
-    const containerMap = listWebManyoyoContainers(ctx, state);
+    const containerMap = listWebManyoyoContainers(ctx);
     const containerInfo = containerMap[sessionRef.containerName] || {};
     const normalizedContainerTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
     if (normalizedContainerTemplate !== history.agentPromptCommand) {
@@ -2745,11 +2680,26 @@ function parseAndValidateConfigRaw(raw) {
     return config;
 }
 
+// 新建容器对话框会拿 defaults.hostPath 做预填，但 validateHostPath 明确拒绝
+// 根目录 / /home / $HOME。serve 以 $HOME 启动（root 用户下就是 /root）时，
+// 预填的值必定创建失败——这里直接留空，逼用户用"选择"选一个真实工作目录
+function sanitizeDefaultHostPath(hostPath) {
+    const value = String(hostPath || '').trim();
+    if (!value) {
+        return '';
+    }
+    const homeDir = process.env.HOME || os.homedir() || '/home';
+    if (value === '/' || value === '/home' || value === homeDir) {
+        return '';
+    }
+    return value;
+}
+
 function buildConfigDefaults(ctx, config) {
     const parsed = toPlainObject(config);
     const defaults = {
         containerName: hasOwn(parsed, 'containerName') ? String(parsed.containerName || '') : '',
-        hostPath: pickFirstString(parsed.hostPath, ctx.hostPath),
+        hostPath: sanitizeDefaultHostPath(pickFirstString(parsed.hostPath, ctx.hostPath)),
         containerPath: pickFirstString(parsed.containerPath, ctx.containerPath),
         imageName: pickFirstString(parsed.imageName, ctx.imageName),
         imageVersion: pickFirstString(parsed.imageVersion, ctx.imageVersion),
@@ -3036,7 +2986,7 @@ function buildCreateRuntime(ctx, state, payload) {
 }
 
 function resolveUniqueContainerName(ctx, state, baseName) {
-    const containerMap = listWebManyoyoContainers(ctx, state);
+    const containerMap = listWebManyoyoContainers(ctx);
     const historyNames = listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName);
     const taken = new Set([...Object.keys(containerMap), ...historyNames]);
     // 基于历史最大编号 +1 命名，即使较小编号的副本被删除也不回收其编号，
@@ -3117,7 +3067,7 @@ async function createClonedContainer(ctx, state, sourceContainerName, requestedN
     let finalName = '';
     if (requestedName) {
         validateContainerNameStrict(requestedName);
-        const containerMap = listWebManyoyoContainers(ctx, state);
+        const containerMap = listWebManyoyoContainers(ctx);
         const historyNames = listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName);
         const taken = new Set([...Object.keys(containerMap), ...historyNames]);
         if (taken.has(requestedName)) {
@@ -3181,20 +3131,7 @@ function estimateStartTimeFromStatus(status) {
     return null;
 }
 
-// 同一进程内短 TTL 缓存：GET /api/sessions、/detail 等接口各自独立调用这个函数，
-// 容器一多时 docker ps + 批量 inspect 本身就不便宜，多标签页轮询会让它们在
-// 短时间内反复触发。2 秒内的重复调用直接复用上一次结果，不再次触碰
-// ctx.dockerExecArgs（同步 spawnSync，会独占事件循环）。
-const CONTAINER_LIST_CACHE_TTL_MS = 2000;
-
-function listWebManyoyoContainers(ctx, state) {
-    if (state && state._containerListCache) {
-        const { timestamp, data } = state._containerListCache;
-        if (Date.now() - timestamp < CONTAINER_LIST_CACHE_TTL_MS) {
-            return data;
-        }
-    }
-
+function listWebManyoyoContainers(ctx) {
     const output = ctx.dockerExecArgs(
         ['ps', '-a', '--format', '{{.Names}}\t{{.Status}}\t{{.Image}}'],
         { ignoreError: true }
@@ -3202,9 +3139,6 @@ function listWebManyoyoContainers(ctx, state) {
 
     const map = {};
     if (!output.trim()) {
-        if (state) {
-            state._containerListCache = { timestamp: Date.now(), data: map };
-        }
         return map;
     }
 
@@ -3222,8 +3156,11 @@ function listWebManyoyoContainers(ctx, state) {
     });
 
     // 逐容器单独 docker inspect 是 N+1 同步阻塞调用（spawnSync 无 timeout，会
-    // 独占 Node 单线程事件循环）；容器一多，serve 所有接口（包括正在流式输出
-    // 的 agent/stream）都会被拖慢甚至冻结。这里合并成一次批量 inspect。
+    // 独占 Node 单线程事件循环），这里合并成一次批量 inspect。
+    // 注意：31 个容器实测 `ps -a` 约 40ms、批量 `inspect` 约 45ms，容器运行时调用
+    // 并不是 GET /api/sessions 慢的原因——真正的开销在逐容器同步读取并解析整份
+    // 历史 JSON（见 buildSessionSummary 的 preloadedHistory 注释）。排查这条路径
+    // 变慢时别先怀疑 docker/podman。
     const defaultCommandByName = {};
     if (candidates.length) {
         let inspectOutput = '';
@@ -3261,9 +3198,6 @@ function listWebManyoyoContainers(ctx, state) {
         };
     });
 
-    if (state) {
-        state._containerListCache = { timestamp: Date.now(), data: map };
-    }
     return map;
 }
 
@@ -3721,24 +3655,38 @@ async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerNa
     const sessionRef = typeof sessionRefOrContainerName === 'string'
         ? { containerName: sessionRefOrContainerName, agentId: WEB_DEFAULT_AGENT_ID }
         : sessionRefOrContainerName;
-    const sessionKey = buildWebSessionKey(sessionRef.containerName, sessionRef.agentId);
     const agentProgram = typeof opts.agentProgram === 'string' ? opts.agentProgram : '';
     const onEvent = typeof opts.onEvent === 'function' ? opts.onEvent : () => {};
-    const process = spawn(
-        ctx.dockerCmd,
-        ['exec', sessionRef.containerName, '/bin/bash', '-lc', command],
-        { stdio: ['ignore', 'pipe', 'pipe'] }
-    );
+    // 调用方可能已经在路由入口占过锁（见 reserveWebAgentRun）：复用那一份 runState，
+    // 不要另起一个对象，否则 stopWebAgentRun 拿到的还是占位、杀不到真正的进程
+    const runState = opts.runState && typeof opts.runState === 'object'
+        ? opts.runState
+        : reserveWebAgentRun(state, sessionRef);
+    let process;
+    try {
+        process = spawn(
+            ctx.dockerCmd,
+            ['exec', sessionRef.containerName, '/bin/bash', '-lc', command],
+            { stdio: ['ignore', 'pipe', 'pipe'] }
+        );
+    } catch (e) {
+        // spawn 同步抛错（如 dockerCmd 不存在）时必须释放锁，否则这个容器永远发不出消息
+        releaseWebAgentRun(state, sessionRef.containerName, runState);
+        throw e;
+    }
 
-    const runState = {
-        containerName: sessionRef.containerName,
-        sessionKey,
-        process,
-        command,
-        startedAt: new Date().toISOString(),
-        stopping: false
-    };
+    runState.process = process;
+    runState.command = command;
+    runState.startedAt = new Date().toISOString();
     state.agentRuns.set(sessionRef.containerName, runState);
+    // 准备阶段（拉起容器等）用户就点了停止：进程刚 spawn 出来立刻收掉
+    if (runState.stopping === true) {
+        try {
+            process.kill('SIGTERM');
+        } catch (e) {
+            // 进程可能已经退出，忽略
+        }
+    }
 
     return await new Promise((resolve, reject) => {
         const MAX_RAW_OUTPUT_CHARS = 32 * 1024 * 1024;
@@ -3798,7 +3746,13 @@ async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerNa
                         }
                         onEvent({
                             type: 'content_delta',
-                            content: contentDeltaAccumulator
+                            content: contentDeltaAccumulator,
+                            // token 级增量标记为 partial：调用方据此跳过事件日志、
+                            // 并对历史落盘做节流（否则每个 token 都要重写一次历史 JSON）；
+                            // chunk/chunkReset 只在 partial 时有意义，见 extractContentDeltaFromPayload
+                            partial: deltaContent.partial === true,
+                            chunk: typeof deltaContent.chunk === 'string' ? deltaContent.chunk : '',
+                            chunkReset: deltaContent.chunkReset === true
                         });
                     }
                     return;
@@ -3850,11 +3804,11 @@ async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerNa
         });
 
         process.on('error', error => {
-            state.agentRuns.delete(sessionRef.containerName);
+            releaseWebAgentRun(state, sessionRef.containerName, runState);
             reject(error);
         });
         process.on('close', code => {
-            state.agentRuns.delete(sessionRef.containerName);
+            releaseWebAgentRun(state, sessionRef.containerName, runState);
             if (stdoutPending) {
                 emitStdoutTraceLine(stdoutPending);
                 stdoutPending = '';
@@ -3920,9 +3874,9 @@ function sendNdjson(res, payload) {
     res.write(`${JSON.stringify(payload)}\n`);
 }
 
-function createWebStreamEmitter(res, state, sessionRef) {
+function createWebStreamEmitter(res, webHistoryDir, sessionRef) {
     return (payload, type, data = {}) => {
-        const controlEvent = appendWebSessionControlEvent(state, sessionRef, type, data);
+        const controlEvent = appendWebSessionControlEvent(webHistoryDir, sessionRef, type, data);
         sendNdjson(res, { ...payload, controlEvent });
     };
 }
@@ -3937,9 +3891,43 @@ function resolveWebStreamControlEventType(event) {
     return 'process.stdout';
 }
 
+// 容器级运行锁的"占位"。必须在路由里同步调用：从 409 检查到真正 spawn 之间隔着
+// readJsonBody / prepareWebAgentExecution（含 ensureWebContainer 拉起容器）等多个
+// await，容器冷启动时这个窗口有好几秒。不先占住的话第二次发送会穿过 409 检查，
+// 同一容器里真的跑起两个 agent 进程，而且后者会覆盖前者的运行登记，
+// 让第一个进程再也停不掉
+function reserveWebAgentRun(state, sessionRef) {
+    const runState = {
+        containerName: sessionRef.containerName,
+        sessionKey: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
+        process: null,
+        command: '',
+        startedAt: new Date().toISOString(),
+        stopping: false
+    };
+    state.agentRuns.set(sessionRef.containerName, runState);
+    return runState;
+}
+
+// 只有占位仍是自己那一份时才释放，避免误删别人的登记
+function releaseWebAgentRun(state, containerName, runState) {
+    if (state.agentRuns.get(containerName) === runState) {
+        state.agentRuns.delete(containerName);
+    }
+}
+
 function stopWebAgentRun(state, containerName) {
     const runState = state.agentRuns.get(containerName);
-    if (!runState || !runState.process || runState.process.killed) {
+    if (!runState) {
+        return false;
+    }
+    if (!runState.process) {
+        // 还在准备阶段（拉起容器 / 探测 resume），进程尚未 spawn：先记下停止意图，
+        // execAgentInWebContainerStream 拿到进程后会立刻收掉它
+        runState.stopping = true;
+        return true;
+    }
+    if (runState.process.killed) {
         return false;
     }
     runState.stopping = true;
@@ -4016,10 +4004,15 @@ function getValidSessionRef(ctx, res, encodedName) {
     return parsed;
 }
 
-function buildSessionSummary(ctx, state, containerMap, sessionRef) {
+// preloadedHistory：调用方已经读过同一个容器的历史时直接复用。历史 JSON 是整份
+// 读文件 + JSON.parse，容器多、agent 多时按 agent 数重复读会把 GET /api/sessions
+// 拖到秒级，而它是同步 IO——事件循环被占住期间 agent/stream 的输出只能攒着分批推
+function buildSessionSummary(ctx, state, containerMap, sessionRef, preloadedHistory = null) {
     const containerName = sessionRef && sessionRef.containerName ? sessionRef.containerName : '';
     const agentId = sessionRef && sessionRef.agentId ? sessionRef.agentId : WEB_DEFAULT_AGENT_ID;
-    const history = loadWebSessionHistory(state.webHistoryDir, containerName);
+    const history = preloadedHistory && typeof preloadedHistory === 'object'
+        ? preloadedHistory
+        : loadWebSessionHistory(state.webHistoryDir, containerName);
     const realAgentSession = getWebAgentSession(history, agentId, { includeArchived: true });
     const agentSession = realAgentSession
         || (agentId === WEB_DEFAULT_AGENT_ID ? createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID) : null);
@@ -4039,6 +4032,7 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef) {
             status: containerInfo.status || 'history',
             defaultCommand: containerInfo.defaultCommand || ''
         });
+    const agentRunState = state.agentRuns ? state.agentRuns.get(containerName) : undefined;
     const createdAt = agentSession.createdAt || containerInfo.createdAt || null;
     const updatedAt = agentSession.updatedAt
         || (latestMessage && latestMessage.timestamp)
@@ -4065,6 +4059,11 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef) {
         hostPath: applied.hostPath || '',
         containerPath: applied.containerPath || '',
         archived: agentSession.archived === true,
+        // 运行锁是容器级的，界面却是 agent 级的：把"容器在忙"和"是不是自己在忙"
+        // 都透出去，同容器的其他 AGENT 才能提前禁用输入，而不是点了发送才吃 409
+        containerBusy: agentRunState !== undefined,
+        agentRunning: agentRunState !== undefined
+            && agentRunState.sessionKey === buildWebSessionKey(containerName, agentId),
         ...(synthetic ? { synthetic: true } : {})
     };
 }
@@ -4116,7 +4115,7 @@ function buildSessionDetail(ctx, state, containerMap, name) {
         sessionRef.agentId,
         containerInfo.defaultCommand
     );
-    const summary = buildSessionSummary(ctx, state, containerMap, sessionRef);
+    const summary = buildSessionSummary(ctx, state, containerMap, sessionRef, history);
     const agentSession = getWebAgentSession(history, sessionRef.agentId, { includeArchived: true })
         || (sessionRef.agentId === WEB_DEFAULT_AGENT_ID ? createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID) : null);
     const latestMessage = agentSession && agentSession.messages.length
@@ -4159,7 +4158,7 @@ function buildSessionAudit(ctx, state, sessionRef) {
     const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
     const agentSession = getWebAgentSession(history, sessionRef.agentId, { includeArchived: true })
         || createEmptyWebAgentSession(sessionRef.agentId);
-    const events = loadWebSessionControlEvents(state, sessionRef, agentSession.events);
+    const events = loadWebSessionControlEvents(state.webHistoryDir, sessionRef, agentSession.events);
     const applied = history.applied && typeof history.applied === 'object' && !Array.isArray(history.applied)
         ? history.applied
         : {};
@@ -4290,123 +4289,6 @@ function renderLoginHtml(ctx) {
     return applyServeTitle(loadTemplate('login.html'), ctx);
 }
 
-// DIAG_LOG：临时诊断日志查看页，自成一个内联 HTML 字符串（不接入 frontend-shadcn
-// 构建流程），配合 /api/diag/logs 接口使用。排查结束后可整体删除本函数及其
-// 调用点（全局搜索 "DIAG_LOG"）。
-function renderDiagLogsHtml() {
-    return `<!DOCTYPE html>
-<html lang="zh-CN">
-<head>
-<meta charset="UTF-8">
-<title>MANYOYO 诊断日志</title>
-<style>
-  body { margin: 0; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; background: #0b0d12; color: #d7dae0; }
-  header { padding: 12px 16px; display: flex; gap: 8px; flex-wrap: wrap; align-items: center; border-bottom: 1px solid #262b36; position: sticky; top: 0; background: #0b0d12; }
-  header input, header select { background: #171a21; border: 1px solid #2c313d; color: #d7dae0; padding: 5px 8px; border-radius: 4px; font-size: 13px; }
-  header button { background: #2b6cb0; border: none; color: #fff; padding: 6px 12px; border-radius: 4px; cursor: pointer; font-size: 13px; }
-  header button.secondary { background: #2c313d; }
-  header label { font-size: 12px; display: flex; align-items: center; gap: 4px; }
-  main { padding: 8px 16px 40px; }
-  table { width: 100%; border-collapse: collapse; font-size: 12px; }
-  th, td { text-align: left; padding: 4px 8px; border-bottom: 1px solid #1c202a; vertical-align: top; white-space: pre-wrap; word-break: break-all; }
-  th { position: sticky; top: 53px; background: #0b0d12; color: #8b93a3; font-weight: 600; }
-  tr:hover { background: #12151c; }
-  .cat { display: inline-block; padding: 1px 6px; border-radius: 3px; background: #1e2530; color: #8fd3ff; }
-  .status-ok { color: #7ee787; }
-  .status-err { color: #ff7b72; }
-  .dur-slow { color: #ffa657; font-weight: 600; }
-  #count { color: #8b93a3; font-size: 12px; }
-</style>
-</head>
-<body>
-<header>
-  <strong>诊断日志</strong>
-  <label>日期 <input id="f-date" type="text" placeholder="YYYY-MM-DD"></label>
-  <label>分类 <input id="f-category" type="text" placeholder="http_request / docker_exec / stream_event / stream_exec_start / stream_exec_end"></label>
-  <label>会话 <input id="f-session" type="text" placeholder="containerName 或 containerName~agentId"></label>
-  <label>关键字 <input id="f-keyword" type="text" placeholder="任意文本"></label>
-  <label>条数 <input id="f-limit" type="text" value="500" style="width:60px"></label>
-  <button id="btn-refresh">刷新</button>
-  <label><input id="f-auto" type="checkbox"> 每 2 秒自动刷新</label>
-  <span id="count"></span>
-</header>
-<main>
-  <table>
-    <thead><tr><th>时间</th><th>分类</th><th>详情</th></tr></thead>
-    <tbody id="rows"></tbody>
-  </table>
-</main>
-<script>
-(function () {
-  var timer = null;
-  function fmtExtra(entry) {
-    var e = entry.extra || {};
-    var parts = [];
-    if (e.method) parts.push(e.method + ' ' + (e.path || ''));
-    if (typeof e.status === 'number') {
-      parts.push('<span class="' + (e.status < 400 ? 'status-ok' : 'status-err') + '">status=' + e.status + '</span>');
-    }
-    if (typeof e.durationMs === 'number') {
-      parts.push('<span class="' + (e.durationMs > 1000 ? 'dur-slow' : '') + '">' + e.durationMs + 'ms</span>');
-    }
-    if (e.session) parts.push('session=' + e.session);
-    if (e.args) parts.push('args=' + JSON.stringify(e.args));
-    if (e.type) parts.push('type=' + e.type);
-    if (typeof e.seq === 'number') parts.push('seq=' + e.seq);
-    if (typeof e.sinceStartMs === 'number') parts.push('sinceStart=' + e.sinceStartMs + 'ms');
-    if (typeof e.totalDurationMs === 'number') parts.push('total=' + e.totalDurationMs + 'ms');
-    if (typeof e.eventCount === 'number') parts.push('events=' + e.eventCount);
-    if (e.error) parts.push('<span class="status-err">error=' + e.error + '</span>');
-    var rest = {};
-    Object.keys(e).forEach(function (k) {
-      if (['method','path','status','durationMs','session','args','type','seq','sinceStartMs','totalDurationMs','eventCount','error'].indexOf(k) === -1) {
-        rest[k] = e[k];
-      }
-    });
-    if (Object.keys(rest).length) parts.push(JSON.stringify(rest));
-    return parts.join('  ');
-  }
-  function escapeHtml(s) {
-    return String(s == null ? '' : s).replace(/[&<>"']/g, function (c) {
-      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[c];
-    });
-  }
-  function load() {
-    var params = new URLSearchParams();
-    var date = document.getElementById('f-date').value.trim();
-    var category = document.getElementById('f-category').value.trim();
-    var session = document.getElementById('f-session').value.trim();
-    var keyword = document.getElementById('f-keyword').value.trim();
-    var limit = document.getElementById('f-limit').value.trim();
-    if (date) params.set('date', date);
-    if (category) params.set('category', category);
-    if (session) params.set('session', session);
-    if (keyword) params.set('keyword', keyword);
-    if (limit) params.set('limit', limit);
-    fetch('/api/diag/logs?' + params.toString(), { headers: { 'X-Requested-With': 'XMLHttpRequest' } })
-      .then(function (r) { return r.json(); })
-      .then(function (data) {
-        var entries = data.entries || [];
-        document.getElementById('count').textContent = entries.length + ' 条（' + data.date + '）';
-        var rows = entries.slice().reverse().map(function (entry) {
-          return '<tr><td>' + escapeHtml(entry.ts) + '</td><td><span class="cat">' + escapeHtml(entry.category) + '</span></td><td>' + fmtExtra(entry) + '</td></tr>';
-        });
-        document.getElementById('rows').innerHTML = rows.join('');
-      });
-  }
-  document.getElementById('btn-refresh').addEventListener('click', load);
-  document.getElementById('f-auto').addEventListener('change', function (e) {
-    if (timer) { clearInterval(timer); timer = null; }
-    if (e.target.checked) { timer = setInterval(load, 2000); }
-  });
-  load();
-})();
-</script>
-</body>
-</html>
-`;
-}
-
 function toPositiveInt(value, fallback) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isFinite(parsed) || parsed <= 0) {
@@ -4700,23 +4582,6 @@ async function handleWebApi(req, res, pathname, ctx, state) {
         }
     }
     const routes = [
-        // DIAG_LOG：临时诊断日志查询接口，配合 /logs 页面使用，排查完成后与
-        // diagLog/readDiagLogEntries 一起整体删除即可（全局搜索 "DIAG_LOG"）。
-        {
-            method: 'GET',
-            match: currentPath => currentPath === '/api/diag/logs' ? [] : null,
-            handler: async () => {
-                const requestUrl = new URL(req.url || '/api/diag/logs', 'http://localhost');
-                const entries = readDiagLogEntries(ctx, {
-                    date: requestUrl.searchParams.get('date') || undefined,
-                    category: requestUrl.searchParams.get('category') || undefined,
-                    session: requestUrl.searchParams.get('session') || undefined,
-                    keyword: requestUrl.searchParams.get('keyword') || undefined,
-                    limit: Number(requestUrl.searchParams.get('limit')) || undefined
-                });
-                sendJson(res, 200, { date: requestUrl.searchParams.get('date') || getLocalDateTag(), entries });
-            }
-        },
         {
             method: 'GET',
             match: currentPath => currentPath === '/api/fs/directories' ? [] : null,
@@ -4827,7 +4692,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'GET',
             match: currentPath => currentPath === '/api/system/capacity' ? [] : null,
             handler: async () => {
-                const containerMap = listWebManyoyoContainers(ctx, state);
+                const containerMap = listWebManyoyoContainers(ctx);
                 const diskPath = path.dirname(path.resolve(state.webConfigPath));
                 const report = estimateContainerCapacity({
                     runtimeCommand: ctx.dockerCmd || 'docker',
@@ -4904,7 +4769,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'GET',
             match: currentPath => currentPath === '/api/sessions' ? [] : null,
             handler: async () => {
-                const containerMap = listWebManyoyoContainers(ctx, state);
+                const containerMap = listWebManyoyoContainers(ctx);
                 const names = new Set([
                     ...Object.keys(containerMap),
                     ...listWebHistorySessionNames(state.webHistoryDir, ctx.isValidContainerName)
@@ -4917,7 +4782,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                             .map(agentSession => buildSessionSummary(ctx, state, containerMap, {
                                 containerName: name,
                                 agentId: agentSession.agentId
-                            }))
+                            }, history))
                             .filter(Boolean);
                     })
                     .sort(compareWebSessionCreatedDesc);
@@ -5302,7 +5167,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     return;
                 }
 
-                const containerMap = listWebManyoyoContainers(ctx, state);
+                const containerMap = listWebManyoyoContainers(ctx);
                 const detail = buildSessionDetail(ctx, state, containerMap, sessionRef);
                 sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), detail });
             }
@@ -5315,7 +5180,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 if (!sessionRef) {
                     return;
                 }
-                const containerMap = listWebManyoyoContainers(ctx, state);
+                const containerMap = listWebManyoyoContainers(ctx);
                 const containerInfo = containerMap[sessionRef.containerName] || {};
                 const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
                 const effectiveTemplate = resolveEffectiveAgentPromptCommandForSession(
@@ -5413,7 +5278,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     return;
                 }
 
-                const containerMap = listWebManyoyoContainers(ctx, state);
+                const containerMap = listWebManyoyoContainers(ctx);
                 const detail = buildSessionDetail(ctx, state, containerMap, sessionRef);
                 sendJson(res, 200, {
                     saved: true,
@@ -5523,6 +5388,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     sendJson(res, 409, { error: '当前容器已有运行中的 agent 任务，请等它结束或先停止' });
                     return;
                 }
+                // 紧接着检查同步占位，中间不能有 await，否则并发请求会同时穿过上面这道检查
+                const runState = reserveWebAgentRun(state, sessionRef);
 
                 const userMessage = appendWebSessionMessage(state.webHistoryDir, sessionRef, 'user', prompt, {
                     mode: 'agent',
@@ -5542,6 +5409,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 try {
                     prepared = await prepareWebAgentExecution(ctx, state, sessionRef, prompt);
                 } catch (e) {
+                    releaseWebAgentRun(state, sessionRef.containerName, runState);
                     removeWebSessionMessage(state.webHistoryDir, sessionRef, traceMessage && traceMessage.id);
                     removeWebSessionMessage(state.webHistoryDir, sessionRef, userMessage && userMessage.id);
                     sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
@@ -5562,7 +5430,30 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     'Cache-Control': 'no-store',
                     'X-Accel-Buffering': 'no'
                 });
-                const emitStreamEvent = createWebStreamEmitter(res, state, sessionRef);
+                // agent 可能几十秒不产生任何输出（长 WebSearch、长 Bash、长思考），
+                // 而反向代理按"上游多久没发字节"计空闲超时（nginx proxy_read_timeout
+                // 默认 60s），超时会 RST 掉这条流，浏览器侧抛 network error。这里定期
+                // 发一行 ping 保活；前端忽略该事件，也不写入会话事件日志
+                const heartbeatMs = ctx.agentStreamHeartbeatMs || DEFAULT_AGENT_STREAM_HEARTBEAT_MS;
+                let lastStreamWriteAt = Date.now();
+                const heartbeatTimer = setInterval(() => {
+                    if (res.writableEnded || res.destroyed) {
+                        return;
+                    }
+                    if (Date.now() - lastStreamWriteAt < heartbeatMs) {
+                        return;
+                    }
+                    sendNdjson(res, { type: 'ping' });
+                    lastStreamWriteAt = Date.now();
+                }, Math.max(50, Math.floor(heartbeatMs / 2)));
+                if (typeof heartbeatTimer.unref === 'function') {
+                    heartbeatTimer.unref();
+                }
+                const rawEmitStreamEvent = createWebStreamEmitter(res, state.webHistoryDir, sessionRef);
+                const emitStreamEvent = (...args) => {
+                    lastStreamWriteAt = Date.now();
+                    return rawEmitStreamEvent(...args);
+                };
                 emitStreamEvent({
                     type: 'meta',
                     containerName: sessionRef.containerName,
@@ -5591,40 +5482,31 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     pending: true
                 });
 
-                const diagStreamStartedAt = Date.now(); // DIAG_LOG
-                let diagEventSeq = 0; // DIAG_LOG
-                diagLog(ctx, 'stream_exec_start', { // DIAG_LOG
-                    session: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
-                    agentProgram: agentMeta.agentProgram,
-                    command
-                });
+                let lastPartialPersistAt = 0;
                 try {
                     const result = await execAgentInWebContainerStream(ctx, state, sessionRef, command, {
                         agentProgram: agentMeta.agentProgram,
+                        // 复用路由入口占好的那把锁，而不是另起一份运行登记
+                        runState,
                         onEvent: event => {
-                            diagEventSeq += 1; // DIAG_LOG
-                            diagLog(ctx, 'stream_event', { // DIAG_LOG
-                                session: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
-                                seq: diagEventSeq,
-                                type: event && event.type,
-                                sinceStartMs: Date.now() - diagStreamStartedAt,
-                                textLength: event && typeof event.text === 'string' ? event.text.length : undefined,
-                                contentLength: event && typeof event.content === 'string' ? event.content.length : undefined
-                            });
+                            // token 级增量：只走网线，不进事件日志，历史落盘按
+                            // AGENT_STREAM_PARTIAL_PERSIST_INTERVAL_MS 节流
+                            const isPartialDelta = event && event.type === 'content_delta' && event.partial === true;
                             if (event && event.type === 'trace' && event.text) {
                                 traceLines.push(String(event.text));
                                 if (event.traceEvent && typeof event.traceEvent === 'object') {
                                     traceEvents.push(event.traceEvent);
                                 }
-                                if (shouldFlushLiveHistory(state, buildWebSessionKey(sessionRef.containerName, sessionRef.agentId))) {
-                                    patchWebSessionMessage(state.webHistoryDir, sessionRef, traceMessage && traceMessage.id, {
-                                        content: traceLines.join('\n'),
-                                        traceEvents: traceEvents.slice(),
-                                        pending: true
-                                    });
-                                }
+                                patchWebSessionMessage(state.webHistoryDir, sessionRef, traceMessage && traceMessage.id, {
+                                    content: traceLines.join('\n'),
+                                    traceEvents: traceEvents.slice(),
+                                    pending: true
+                                });
                             }
                             if (event && event.type === 'content_delta' && typeof event.content === 'string') {
+                                const now = Date.now();
+                                const shouldPersist = !isPartialDelta
+                                    || now - lastPartialPersistAt >= AGENT_STREAM_PARTIAL_PERSIST_INTERVAL_MS;
                                 if (!streamingReplyMessageId) {
                                     const streamingReplyMessage = appendWebSessionMessage(
                                         state.webHistoryDir,
@@ -5640,26 +5522,30 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                                     streamingReplyMessageId = streamingReplyMessage && streamingReplyMessage.id
                                         ? streamingReplyMessage.id
                                         : '';
-                                } else if (shouldFlushLiveHistory(state, buildWebSessionKey(sessionRef.containerName, sessionRef.agentId))) {
+                                    lastPartialPersistAt = now;
+                                } else if (shouldPersist) {
                                     patchWebSessionMessage(state.webHistoryDir, sessionRef, streamingReplyMessageId, {
                                         content: event.content,
                                         pending: true
                                     });
+                                    lastPartialPersistAt = now;
                                 }
                             }
+                            if (isPartialDelta) {
+                                lastStreamWriteAt = Date.now();
+                                // 只发增量片段：前端在 content_chunk 上做追加，
+                                // reset 表示换了一条 assistant 消息、从空白重新开始
+                                sendNdjson(res, event.chunkReset === true
+                                    ? { type: 'content_chunk', text: '', reset: true }
+                                    : { type: 'content_chunk', text: event.chunk });
+                                return;
+                            }
                             emitStreamEvent(event, resolveWebStreamControlEventType(event), {
                                 transportType: event && event.type ? event.type : '',
                                 text: event && (event.text || event.content) ? String(event.text || event.content) : ''
                             });
                         }
                     });
-                    diagLog(ctx, 'stream_exec_end', { // DIAG_LOG
-                        session: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
-                        totalDurationMs: Date.now() - diagStreamStartedAt,
-                        eventCount: diagEventSeq,
-                        interrupted: result.interrupted === true,
-                        exitCode: result.exitCode
-                    });
                     traceLines.push(result.interrupted === true ? '[任务] 已停止' : '[任务] 已完成');
                     patchWebSessionMessage(state.webHistoryDir, sessionRef, userMessage && userMessage.id, {
                         pending: false,
@@ -5723,6 +5609,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                         error: e && e.message ? e.message : 'Agent 执行失败'
                     }, 'agent.turn.failed', { error: e && e.message ? e.message : 'Agent 执行失败' });
                 } finally {
+                    clearInterval(heartbeatTimer);
                     res.end();
                 }
             }
@@ -5743,7 +5630,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     sendJson(res, 404, { error: '当前会话没有运行中的 agent 任务' });
                     return;
                 }
-                appendWebSessionControlEvent(state, sessionRef, 'session.stopping');
+                appendWebSessionControlEvent(state.webHistoryDir, sessionRef, 'session.stopping');
                 sendJson(res, 200, { ok: true, stopping: true });
             }
         },
@@ -5762,7 +5649,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
 
                 if (removeHistory) {
                     const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
-                    removeAllAgentHistoryArtifacts(state, sessionRef.containerName, Object.keys(history.agents || {}));
+                    removeAllAgentHistoryArtifacts(state.webHistoryDir, sessionRef.containerName, Object.keys(history.agents || {}));
                     removeWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
                 } else if (removedContainer) {
                     appendWebSessionMessage(state.webHistoryDir, sessionRef, 'system', `容器 ${sessionRef.containerName} 已删除。`);
@@ -5791,7 +5678,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 if (history.agents && typeof history.agents === 'object') {
                     if (removeHistory) {
                         delete history.agents[sessionRef.agentId];
-                        removeAllAgentHistoryArtifacts(state, sessionRef.containerName, [sessionRef.agentId]);
+                        removeAllAgentHistoryArtifacts(state.webHistoryDir, sessionRef.containerName, [sessionRef.agentId]);
                     } else if (history.agents[sessionRef.agentId]) {
                         history.agents[sessionRef.agentId].archived = true;
                         history.agents[sessionRef.agentId].updatedAt = new Date().toISOString();
@@ -5861,6 +5748,10 @@ async function startWebServer(options) {
         showImagePullHint: options.showImagePullHint,
         removeContainer: options.removeContainer,
         logger: options.logger && typeof options.logger.info === 'function' ? options.logger : fallbackLogger,
+        // agent/stream 的保活心跳间隔，需小于反向代理的空闲读超时（nginx 默认 60s）
+        agentStreamHeartbeatMs: Number.isFinite(options.agentStreamHeartbeatMs) && options.agentStreamHeartbeatMs > 0
+            ? options.agentStreamHeartbeatMs
+            : DEFAULT_AGENT_STREAM_HEARTBEAT_MS,
         colors: options.colors || {
             GREEN: '',
             CYAN: '',
@@ -5873,29 +5764,6 @@ async function startWebServer(options) {
         throw new Error('Web 认证配置缺失，请设置 serve -U / serve -P');
     }
 
-    // DIAG_LOG：包一层记录每次 docker/podman 子进程调用的参数与耗时，覆盖
-    // listWebManyoyoContainers、ensureWebContainer 等所有经由 ctx.dockerExecArgs
-    // 发起的调用，不需要逐个调用点单独打点。
-    if (typeof ctx.dockerExecArgs === 'function') {
-        const rawDockerExecArgs = ctx.dockerExecArgs;
-        ctx.dockerExecArgs = (args, execOptions) => {
-            const startedAt = Date.now();
-            let errorMessage = '';
-            try {
-                return rawDockerExecArgs(args, execOptions);
-            } catch (e) {
-                errorMessage = e && e.message ? e.message : String(e);
-                throw e;
-            } finally {
-                diagLog(ctx, 'docker_exec', {
-                    args: Array.isArray(args) ? args : [],
-                    durationMs: Date.now() - startedAt,
-                    error: errorMessage || undefined
-                });
-            }
-        };
-    }
-
     const state = {
         webHistoryDir: options.webHistoryDir || path.join(os.homedir(), '.manyoyo', 'web-history'),
         webConfigPath: options.webConfigPath || getDefaultWebConfigPath(),
@@ -5903,11 +5771,6 @@ async function startWebServer(options) {
         terminalSessions: new Map(),
         agentRuns: new Map()
     };
-    // 跨请求复用同一个 FileEventStore 实例，append() 的增量缓存才能生效
-    // （否则每次都 new 一个新实例，缓存永远命中不到）
-    state.eventStore = new FileEventStore(state.webHistoryDir);
-    // shouldFlushLiveHistory() 的节流状态：aggregateId -> 上次成功落盘的时间戳
-    state._liveHistoryFlushThrottle = new Map();
 
     ensureWebHistoryDir(state.webHistoryDir);
 
@@ -5930,20 +5793,6 @@ async function startWebServer(options) {
     });
 
     const server = http.createServer(async (req, res) => {
-        // DIAG_LOG：记录每个 HTTP 请求从进入到响应完成（含长连接的 agent/stream，
-        // 'finish' 在 chunked 响应整体结束时才触发）的方法/路径/状态码/耗时。
-        const diagRequestStartedAt = Date.now();
-        res.on('finish', () => {
-            const rawPath = String(req.url || '').split('?')[0];
-            const sessionMatch = rawPath.match(/^\/api\/sessions\/([^/]+)/);
-            diagLog(ctx, 'http_request', {
-                method: req.method,
-                path: rawPath,
-                status: res.statusCode,
-                durationMs: Date.now() - diagRequestStartedAt,
-                session: sessionMatch ? decodeURIComponent(sessionMatch[1]) : undefined
-            });
-        });
         try {
             const fallbackHost = `${formatUrlHost(ctx.serverHost)}:${ctx.serverPort}`;
             const url = new URL(req.url, `http://${req.headers.host || fallbackHost}`);
@@ -5978,13 +5827,6 @@ async function startWebServer(options) {
                 return;
             }
 
-            // DIAG_LOG：临时诊断日志查看页，排查完成后与 renderDiagLogsHtml、
-            // /api/diag/logs 一起整体删除即可（全局搜索 "DIAG_LOG"）。
-            if (req.method === 'GET' && pathname === '/logs') {
-                sendHtml(res, 200, renderDiagLogsHtml());
-                return;
-            }
-
             const appFrontendMatch = pathname.match(/^\/app\/frontend\/([A-Za-z0-9._-]+)$/);
             if (req.method === 'GET' && appFrontendMatch) {
                 const assetName = appFrontendMatch[1];