@xcanwin/manyoyo 8.7.1 → 8.7.2

package/lib/web/server.js

@@ -15,6 +15,12 @@ const { applyAptMirror } = require('../mirrors');
 const { BUILTIN_AGENT_INSTRUCTIONS, buildAgentInstructions, composeSystemPrompt, SYSTEM_PROMPT_MAX_CHARS, toTomlBasicString } = require('../agent-instructions');
 const containerState = require('../container-state');
 const sessionMeta = require('./session-meta');
+const agentEffort = require('./agent-effort');
+const agentLight = require('./agent-light-call');
+const webRecap = require('./recap');
+const webExtensions = require('./extensions');
+const agentSide = require('./agent-side');
+const contextUsageLib = require('./context-usage');
 const gitChanges = require('./git-changes');
 const { buildExecArgs, resolveContainerId, readMergedEnv } = require('../container-exec');
 const { createNetworkManager, NETWORK_NAME } = require('../container-network');
@@ -233,14 +239,25 @@ function createEmptyWebAgentSession(agentId, agentName) {
         engineSessionId: '',
         usageTotal: null,
         model: '',
+        // 推理强度：''=默认（不注入，尊重容器 env / 配置）
+        effort: '',
+        // claude 最近一轮结束时的上下文占用（见 lib/web/context-usage.js）
+        contextUsage: null,
         queue: [],
         queuePaused: false,
         title: '',
+        // 自动标题（轻量模型调用生成）与是否已经试过（失败也不重试，避免每次刷新都花钱）
+        autoTitle: '',
+        autoTitleTried: false,
+        // 回顾：{ forMessageId, text, createdAt }，对应哪条最终回复
+        recap: null,
         firstPrompt: '',
         pinned: false,
         slashCommands: null,
         // 回退对话后，下一轮 Claude 命令带 --resume-session-at <uuid>（只用一次）
-        rewindToUuid: ''
+        rewindToUuid: '',
+        // 分叉出来的 AGENT：下一轮 Claude 命令带 --fork-session（从原会话另开一条，拿到新会话 id 后清掉）
+        forkPending: false
     };
 }
 
@@ -293,13 +310,19 @@ function normalizeWebAgentSessionRecord(agentId, rawAgent) {
         engineSessionId: typeof source.engineSessionId === 'string' ? source.engineSessionId : '',
         usageTotal: normalizeWebAgentUsageTotal(source.usageTotal),
         model: normalizeStoredAgentModelValue(source.model),
+        effort: agentEffort.isEffortValue(source.effort) ? source.effort : '',
+        contextUsage: contextUsageLib.normalizeStoredContextUsage(source.contextUsage),
         queue: agentQueue.normalizeStoredQueue(source.queue),
         queuePaused: source.queuePaused === true,
         title: sessionMeta.normalizeTitle(source.title),
+        autoTitle: sessionMeta.normalizeTitle(source.autoTitle),
+        autoTitleTried: source.autoTitleTried === true,
+        recap: webRecap.normalizeStoredRecap(source.recap, text => agentLight.cleanLightText(text, agentLight.RECAP_MAX_CHARS)),
         firstPrompt: sessionMeta.normalizeFirstPrompt(source.firstPrompt),
         pinned: source.pinned === true,
         slashCommands: normalizeStoredSlashCommands(source.slashCommands),
-        rewindToUuid: typeof source.rewindToUuid === 'string' && webRewind.UUID_PATTERN.test(source.rewindToUuid) ? source.rewindToUuid : ''
+        rewindToUuid: typeof source.rewindToUuid === 'string' && webRewind.UUID_PATTERN.test(source.rewindToUuid) ? source.rewindToUuid : '',
+        forkPending: source.forkPending === true
     };
 }
 
@@ -995,6 +1018,11 @@ function renderAgentPromptCommand(template, prompt) {
     return templateText.replace(/\{prompt\}/g, () => safePrompt);
 }
 
+// 推理强度只接受小写字母 2～16 位（claude: low/medium/high/xhigh/max；codex 因模型而异），其余一律当没选
+function normalizeEffortValue(value) {
+    return typeof value === 'string' && /^[a-z]{2,16}$/.test(value) ? value : '';
+}
+
 function buildCodexAgentExecCommand(template, prompt, options = {}) {
     const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
     const sessionId = options && typeof options.sessionId === 'string' ? options.sessionId.trim() : '';
@@ -1015,15 +1043,19 @@ function buildCodexAgentExecCommand(template, prompt, options = {}) {
         // 图片：--image=<路径>（等号形式只吃这一个值，不会把后面的提示词当成图片）；resume 子命令同样支持
         const images = options && Array.isArray(options.images) ? options.images : [];
         const imageFlags = images.map(item => ` --image=${quoteBashSingleValue(item)}`).join('');
+        const effort = normalizeEffortValue(options && options.effort);
+        const effortFlag = effort && !/model_reasoning_effort/.test(suffix)
+            ? ` -c model_reasoning_effort=${effort}`
+            : '';
         const instructionsFlag = instructions && !/developer_instructions/.test(suffix)
             ? ` -c ${quoteBashSingleValue(`developer_instructions=${toTomlBasicString(instructions)}`)}`
             : '';
         if (sessionId) {
             const promptIndex = suffix.indexOf('{prompt}');
             const resumeSuffix = `${suffix.slice(0, promptIndex)}${quoteBashSingleValue(sessionId)} ${suffix.slice(promptIndex)}`;
-            codexTemplate = `${prefix}codex exec resume${injectedFlags}${modelFlag}${instructionsFlag}${imageFlags}${resumeSuffix}`;
+            codexTemplate = `${prefix}codex exec resume${injectedFlags}${modelFlag}${effortFlag}${instructionsFlag}${imageFlags}${resumeSuffix}`;
         } else {
-            codexTemplate = `${prefix}codex exec${injectedFlags}${modelFlag}${instructionsFlag}${imageFlags}${suffix}`;
+            codexTemplate = `${prefix}codex exec${injectedFlags}${modelFlag}${effortFlag}${instructionsFlag}${imageFlags}${suffix}`;
         }
     }
     // 兼容服务：OPENAI_BASE_URL 在容器里由 shell 展开成 -c openai_base_url=…（codex 不认这个环境变量，见 withCodexBaseUrl）
@@ -1050,8 +1082,18 @@ function prependAgentFlags(commandText, matchPattern, flagSpecs) {
     return `${prefix}${suffix}`;
 }
 
+// 计划模式：-p 下 --permission-mode plan 和免确认参数同时出现时计划模式无效（实测），
+// 所以在渲染提示词之前从模板里去掉免确认参数和别的 permission-mode，再加上 plan。只处理模板，不碰提示词
+function applyPlanPermissionMode(templateText) {
+    const stripped = templateText
+        .replace(/(^|\s)--(?:allow-)?dangerously-skip-permissions(?=\s|$)/g, '$1')
+        .replace(/(^|\s)--permission-mode(?:=\S+|\s+\S+)?(?=\s|$)/g, '$1');
+    return stripped.replace(/^((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*claude)\b/, '$1 --permission-mode plan');
+}
+
 function buildClaudeAgentExecCommand(template, prompt, options = {}) {
-    const templateText = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const rawTemplate = normalizeAgentPromptCommandTemplate(template, 'agentPromptCommand');
+    const templateText = options && options.permissionMode === 'plan' ? applyPlanPermissionMode(rawTemplate) : rawTemplate;
     const flagSpecs = [
         { flag: '--verbose', pattern: /(?:^|\s)--verbose(?:\s|$)/ },
         { flag: '--output-format stream-json', pattern: /(?:^|\s)--output-format(?:\s|$)/ },
@@ -1069,6 +1111,9 @@ function buildClaudeAgentExecCommand(template, prompt, options = {}) {
     if (sessionId && resumeAtUuid) {
         flagSpecs.push({ flag: `--resume-session-at ${resumeAtUuid}`, pattern: /(?:^|\s)--resume-session-at(?:\s|$)/ });
     }
+    if (sessionId && options && options.forkSession === true) {
+        flagSpecs.push({ flag: '--fork-session', pattern: /(?:^|\s)--fork-session(?:\s|$)/ });
+    }
     const model = options && typeof options.model === 'string' ? options.model.trim() : '';
     if (model) {
         flagSpecs.push({ flag: `--model ${quoteBashSingleValue(model)}`, pattern: /(?:^|\s)--model(?:\s|$)/ });
@@ -1089,11 +1134,15 @@ function buildClaudeAgentExecCommand(template, prompt, options = {}) {
     if (forwardSubagentText === true) {
         flagSpecs.push({ flag: '--forward-subagent-text', pattern: /(?:^|\s)--forward-subagent-text(?:\s|$)/ });
     }
-    const claudeTemplate = prependAgentFlags(
-        templateText,
-        /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)claude\b)(.*)$/,
-        flagSpecs
-    );
+    const claudePattern = /^(((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)claude\b)(.*)$/;
+    let claudeTemplate = prependAgentFlags(templateText, claudePattern, flagSpecs);
+    // 推理强度：CLAUDE_CODE_EFFORT_LEVEL 优先于 --effort 和 settings（实测），所以只能用命令前缀的环境变量覆盖容器里
+    // 可能设了的值；模板自己写了就以模板为准
+    const effort = normalizeEffortValue(options && options.effort);
+    const claudePrefix = (templateText.match(claudePattern) || [])[2];
+    if (effort && claudePrefix !== undefined && !/(?:^|\s)CLAUDE_CODE_EFFORT_LEVEL=/.test(claudePrefix)) {
+        claudeTemplate = claudeTemplate.replace(/^((?:(?:[A-Za-z_][A-Za-z0-9_]*=)(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|[^\s]+)\s+)*)claude\b/, (match, envPrefix) => `${envPrefix}CLAUDE_CODE_EFFORT_LEVEL=${effort} claude`);
+    }
     const rendered = claudeTemplate === templateText
         ? renderAgentPromptCommand(templateText, prompt)
         : renderAgentPromptCommand(claudeTemplate, prompt);
@@ -1525,10 +1574,13 @@ function normalizeAgentModelCatalogEntry(item) {
     if (!value) {
         return null;
     }
+    const efforts = agentEffort.extractEfforts(item);
     return {
         value,
         label: pickFirstString(item && item.displayName, value),
-        description: pickFirstString(item && item.description)
+        description: pickFirstString(item && item.description),
+        ...(efforts.length ? { efforts } : {}),
+        ...(typeof (item && item.resolvedModel) === 'string' && item.resolvedModel ? { resolvedModel: normalizeStoredAgentModelValue(item.resolvedModel) } : {})
     };
 }
 
@@ -1545,6 +1597,17 @@ function extractClaudeModelsFromControlResponse(payload) {
     return models.map(normalizeAgentModelCatalogEntry).filter(Boolean);
 }
 
+function extractClaudeCommandsFromControlResponse(payload) {
+    if (!payload || payload.type !== 'control_response') {
+        return undefined;
+    }
+    const response = toPlainObject(payload.response);
+    if (response.request_id !== 'manyoyo-command-catalog') {
+        return undefined;
+    }
+    return sessionMeta.normalizeCommandCatalog(toPlainObject(response.response).commands);
+}
+
 function extractCodexModelsFromListResponse(payload) {
     if (!payload || payload.id !== 'manyoyo-model-list' || !payload.result) {
         return undefined;
@@ -1590,11 +1653,73 @@ async function fetchAgentModelCatalogCached(ctx, containerName, agentProgram) {
     return pending;
 }
 
+// 斜杠命令目录（claude 的 initialize 请求，不调用模型）：同样按“容器”缓存 10 分钟，拿不到不缓存
+const commandCatalogCaches = new WeakMap();
+const COMMAND_CATALOG_FAILURE_TTL_MS = 15 * 1000;
+
+async function fetchClaudeCommandCatalogCached(ctx, containerName) {
+    let cache = commandCatalogCaches.get(ctx);
+    if (!cache) {
+        cache = new Map();
+        commandCatalogCaches.set(ctx, cache);
+    }
+    const hit = cache.get(containerName);
+    if (hit && (hit.pending || Date.now() - hit.at < (hit.commands.length ? MODEL_CATALOG_TTL_MS : COMMAND_CATALOG_FAILURE_TTL_MS))) {
+        return hit.pending || hit.commands;
+    }
+    const requestLine = JSON.stringify({
+        type: 'control_request',
+        request_id: 'manyoyo-command-catalog',
+        request: { subtype: 'initialize' }
+    });
+    const pending = runAgentProtocolProcess(
+        ctx,
+        containerName,
+        'claude -p --input-format stream-json --output-format stream-json --verbose',
+        { stdinLines: [requestLine], onLine: extractClaudeCommandsFromControlResponse }
+    ).then(({ result }) => {
+        const commands = Array.isArray(result) ? result : [];
+        // 取不到（容器停了、claude 不在）也记一小会儿：输入框里每敲一个字符都会请求一次，不能每次都进容器等 8 秒
+        cache.set(containerName, { at: Date.now(), commands });
+        return commands;
+    }, () => {
+        cache.set(containerName, { at: Date.now(), commands: [] });
+        return [];
+    });
+    cache.set(containerName, { pending });
+    return pending;
+}
+
+// 当前模型能选的推理强度（空数组 = 确实没有，不显示；null = 目录取不到，不知道）。codex 接了第三方服务时目录里全是 OpenAI 的模型，直接当没有
+async function resolveEffortLevels(ctx, state, sessionRef, currentModel) {
+    const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+    const containerInfo = listWebManyoyoContainers(ctx)[sessionRef.containerName] || {};
+    const agentProgram = resolveAgentProgram(resolveEffectiveAgentPromptCommandForSession(
+        history,
+        sessionRef.agentId,
+        containerInfo.defaultCommand
+    ));
+    if (agentProgram !== 'claude' && agentProgram !== 'codex') {
+        return [];
+    }
+    try {
+        if (agentProgram === 'codex') {
+            const env = readMergedEnv({ homeDir: ctx.homeDir || os.homedir(), dockerExecArgs: ctx.dockerExecArgs }, sessionRef.containerName);
+            if (env.OPENAI_BASE_URL) return [];
+        }
+        const catalog = await fetchAgentModelCatalogCached(ctx, sessionRef.containerName, agentProgram);
+        // 目录取不到（容器没运行、探测超时）= 不知道，和“确实不支持”要分开：不知道时不能改用户已经选好的强度
+        return catalog.length ? agentEffort.effortLevelsFor(agentProgram, catalog, currentModel) : null;
+    } catch (e) {
+        return null;
+    }
+}
+
 // 以会话实际配置的 env 生成模型选项。defaultModel 是“跟随默认”实际用的模型；
 // Claude 另有按档位别名（opus / sonnet / haiku …）一行一个的选项：value 是别名（--model opus 由 CLI 按 env 解析），
 // label 是该档位对应的真实模型名。不同档位指向同一个模型也各占一行，不合并。
 // 只读 *_MODEL 这类非敏感键，容器可写的 env 只用来展示，不参与任何安全判断
-const CLAUDE_TIER_ORDER = ['opus', 'fable', 'sonnet', 'haiku'];
+const CLAUDE_TIER_ORDER = ['fable', 'opus', 'sonnet', 'haiku'];
 
 function buildEnvModelOptions(agentProgram, env) {
     const source = env && typeof env === 'object' ? env : {};
@@ -2382,7 +2507,7 @@ function prepareCodexTraceEvent(payload) {
     });
 }
 
-async function prepareWebAgentExecution(ctx, state, sessionRef, prompt, images = []) {
+async function prepareWebAgentExecution(ctx, state, sessionRef, prompt, images = [], turnOptions = {}) {
     const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
     const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true, includeArchived: true });
     const containerMap = listWebManyoyoContainers(ctx);
@@ -2448,9 +2573,12 @@ async function prepareWebAgentExecution(ctx, state, sessionRef, prompt, images =
     const command = buildWebAgentExecCommand(effectiveTemplate, effectivePrompt, agentMeta.agentProgram, {
         sessionId: sessionIdForRun,
         model: agentSession.model || '',
+        effort: agentSession.effort || '',
         forwardSubagentText: agentMeta.agentProgram === 'claude' ? 'auto' : false,
         images: imagesByFlag ? images : [],
         resumeAtUuid: agentSession.rewindToUuid || '',
+        forkSession: agentSession.forkPending === true,
+        permissionMode: turnOptions.permissionMode === 'plan' && agentMeta.agentProgram === 'claude' ? 'plan' : '',
         instructions: buildAgentInstructions(
             configSnapshot.parseError ? {} : configSnapshot.parsed,
             runName,
@@ -2485,20 +2613,36 @@ function finalizeWebAgentExecution(state, sessionRef, agentSession, agentMeta, m
         ...(result.networkDenied ? { networkDenied: result.networkDenied } : {}),
         ...(turnUsage ? { usage: turnUsage } : {})
     });
+    // 分叉的第一轮：命令里带的是原会话 id，输出里的才是新会话 id
+    const extractedSessionId = extractEngineSessionId(agentMeta.agentProgram, result.stdout);
+    const engineSessionIdNow = agentSession.forkPending === true
+        ? extractedSessionId || meta.engineSessionId
+        : meta.engineSessionId || extractedSessionId;
+    // 分叉出来的 AGENT 第一轮：拿到了新的会话 id 才算分叉成功。没成功（命令失败）就保留 forkPending 和回退位置，
+    // 下一轮仍然是分叉，不能退化成直接续接原会话（那会改写原 AGENT 的会话）
+    // （命令在 init 之后才失败时输出里也有新 id，但新会话可能没落盘完整：这一轮必须成功才算分叉完成）
+    const forkDone = agentSession.forkPending === true && Boolean(engineSessionIdNow) && engineSessionIdNow !== agentSession.engineSessionId
+        && result.exitCode === 0 && result.interrupted !== true;
+    const keepFork = agentSession.forkPending === true && !forkDone;
     const patch = {
-        rewindToUuid: '',
+        rewindToUuid: keepFork ? agentSession.rewindToUuid || '' : '',
+        ...(agentSession.forkPending === true && forkDone ? { forkPending: false } : {}),
         lastResumeAt: meta.resumeAttempted ? new Date().toISOString() : (agentSession.lastResumeAt || null),
         lastResumeOk: meta.resumeAttempted ? meta.resumeSucceeded : agentSession.lastResumeOk,
         lastResumeError: meta.resumeAttempted ? (meta.resumeSucceeded ? '' : meta.resumeError) : (agentSession.lastResumeError || '')
     };
-    const engineSessionId = meta.engineSessionId || extractEngineSessionId(agentMeta.agentProgram, result.stdout);
-    if (engineSessionId) {
-        patch.engineSessionId = engineSessionId;
+    if (engineSessionIdNow) {
+        patch.engineSessionId = engineSessionIdNow;
     }
     if (turnUsage) {
         patch.usageTotal = accumulateUsageTotal(agentSession.usageTotal, turnUsage);
     }
     if (agentMeta.agentProgram === 'claude') {
+        // 上下文占用：只在轮结束时写一次；这一轮拿不到数据就保留上一次的
+        const contextUsage = contextUsageLib.extractClaudeContextUsage(result.stdoutTail || result.stdout);
+        if (contextUsage) {
+            patch.contextUsage = { ...contextUsage, updatedAt: new Date().toISOString() };
+        }
         const slashCommands = extractClaudeInitSlashCommands(result.stdout);
         if (slashCommands) {
             patch.slashCommands = slashCommands;
@@ -2625,7 +2769,7 @@ async function rewindWebSessionLocked(ctx, state, sessionRef, scope, target) {
         if (!removed.length) {
             return { status: 409, error: '这条提示词已经不在了' };
         }
-        patchWebAgentSessionState(state.webHistoryDir, sessionRef, { engineSessionId, rewindToUuid });
+        patchWebAgentSessionState(state.webHistoryDir, sessionRef, { engineSessionId, rewindToUuid, contextUsage: null });
         appendWebSessionControlEvent(state.webHistoryDir, sessionRef, 'session.stopped', { reason: 'rewind', scope });
     }
     return { ok: true, scope, filesRestored, conversationMode, prompt: message.content, images: Array.isArray(message.images) ? message.images : [] };
@@ -2681,6 +2825,296 @@ async function refreshWebAgentTitle(ctx, state, sessionRef, agentProgram) {
     }
 }
 
+// 轻量模型调用（标题、回顾）：不占容器运行锁，同一 AGENT 同一种用途同时最多一个，超时 90 秒，失败返回空串。
+// 高频路径，失败不写日志
+const lightCallsInFlight = new WeakMap();
+
+async function runWebLightCall(ctx, state, sessionRef, agentProgram, kind, rule, input, maxChars) {
+    if (agentProgram !== 'claude' && agentProgram !== 'codex') {
+        return '';
+    }
+    let inFlight = lightCallsInFlight.get(ctx);
+    if (!inFlight) {
+        inFlight = new Set();
+        lightCallsInFlight.set(ctx, inFlight);
+    }
+    const flightKey = `${sessionRef.containerName}\u0000${sessionRef.agentId}\u0000${kind}`;
+    if (inFlight.has(flightKey)) {
+        return '';
+    }
+    inFlight.add(flightKey);
+    try {
+        const agentSession = getWebAgentSession(
+            loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName),
+            sessionRef.agentId,
+            { includeArchived: true }
+        );
+        let env = {};
+        try {
+            env = readMergedEnv({ homeDir: ctx.homeDir || os.homedir(), dockerExecArgs: ctx.dockerExecArgs }, sessionRef.containerName);
+        } catch (e) { /* 读不到 env 就按没有处理 */ }
+        const model = agentSession ? agentSession.model || '' : '';
+        const run = command => runWebSideCommand(ctx, sessionRef.containerName, command, { timeoutMs: agentLight.LIGHT_CALL_TIMEOUT_MS });
+        let text = '';
+        if (agentProgram === 'claude') {
+            const command = agentLight.buildClaudeLightCommand({ rule, input, model: agentLight.pickClaudeLightModel(env, model) });
+            text = agentLight.parseClaudeLightOutput((await run(command)).stdout);
+        } else {
+            const prompt = agentLight.buildCodexLightPrompt(rule, input);
+            const attempt = async withEffort => {
+                const template = withEffort ? agentLight.CODEX_LIGHT_TEMPLATE : agentLight.CODEX_LIGHT_TEMPLATE.replace(' -c model_reasoning_effort=low', '');
+                const { stdout } = await run(buildCodexAgentExecCommand(template, prompt, { model }));
+                return extractAgentMessageFromStructuredOutput('codex', stdout);
+            };
+            // 有的模型不接受 low：去掉强度再试一次
+            text = await attempt(true) || await attempt(false);
+        }
+        return agentLight.cleanLightText(text, maxChars);
+    } catch (e) {
+        return '';
+    } finally {
+        inFlight.delete(flightKey);
+    }
+}
+
+// 侧问：不占容器运行锁，同一 AGENT 同时一个。命令和主任务一样套上 PID 文件包装，
+// 客户端断开 / 超时时进到容器里终止（只杀宿主机上的 exec 客户端，容器里的进程会继续跑）
+const sideQuestionsInFlight = new WeakMap();
+
+function runWebSideCommand(ctx, containerName, command, { onAbortSignal, timeoutMs }) {
+    return new Promise(resolve => {
+        const runState = { runId: agentRunControl.createRunId(), containerName, process: null, closed: null };
+        let stdout = '';
+        let settled = false;
+        let child;
+        try {
+            child = spawnContainerExec(
+                ctx,
+                containerName,
+                { command: ['/bin/bash', '-lc', agentRunControl.wrapAgentCommand(command, runState.runId)] },
+                { stdio: ['ignore', 'pipe', 'ignore'] }
+            );
+        } catch (e) {
+            resolve({ stdout: '', error: '启动失败' });
+            return;
+        }
+        runState.process = child;
+        let markClosed;
+        runState.closed = new Promise(done => { markClosed = done; });
+        let aborted = '';
+        const stop = reason => {
+            if (settled || aborted) return;
+            aborted = reason;
+            terminateWebAgentRun(ctx, runState);
+        };
+        const timer = setTimeout(() => stop('timeout'), timeoutMs);
+        if (typeof onAbortSignal === 'function') onAbortSignal(() => stop('aborted'));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', chunk => { if (stdout.length < 4 * 1024 * 1024) stdout += chunk; });
+        const finish = () => {
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            markClosed();
+            resolve({ stdout, aborted });
+        };
+        child.once('close', finish);
+        child.once('error', finish);
+    });
+}
+
+async function answerWebSideQuestion(ctx, state, sessionRef, agentProgram, agentSession, question, onAbortSignal) {
+    const options = { model: agentSession.model || '', effort: agentSession.effort || '' };
+    let command;
+    if (agentProgram === 'claude') {
+        command = agentSide.buildClaudeSideCommand({ sessionId: agentSession.engineSessionId, ...options, question });
+    } else {
+        command = buildCodexAgentExecCommand(agentSide.buildCodexSideTemplate({ threadId: agentSession.engineSessionId, ...options }), question, {});
+    }
+    const { stdout, aborted } = await runWebSideCommand(ctx, sessionRef.containerName, command, {
+        onAbortSignal,
+        timeoutMs: ctx.sideQuestionTimeoutMs || agentSide.SIDE_TIMEOUT_MS
+    });
+    if (aborted) {
+        return { error: aborted === 'timeout' ? '侧问超时，已停止' : '已取消' };
+    }
+    const answer = agentProgram === 'claude'
+        ? agentLight.parseClaudeLightOutput(stdout)
+        : extractAgentMessageFromStructuredOutput('codex', stdout);
+    return answer && answer.trim() ? { answer: agentSide.clipAnswer(answer) } : { error: 'Agent 没有给出回答' };
+}
+
+const EXTENSION_AGENTS = [
+    { program: 'claude', label: 'Claude Code' },
+    { program: 'codex', label: 'Codex CLI' }
+];
+
+async function readWebExtensions(ctx, containerName) {
+    const probe = async command => (await runAgentProtocolProcess(ctx, containerName, command, { timeoutMs: 10000 })).stdout;
+    const present = await Promise.all(EXTENSION_AGENTS.map(async agent => (await probe(`command -v ${agent.program}`)).trim() !== ''));
+    return Promise.all(EXTENSION_AGENTS.filter((agent, index) => present[index]).map(async agent => {
+        if (agent.program === 'claude') {
+            const [catalog, mcpOutput] = await Promise.all([
+                fetchClaudeCommandCatalogCached(ctx, containerName),
+                runAgentProtocolProcess(ctx, containerName, 'claude mcp list', { timeoutMs: 30000 }).then(item => item.stdout)
+            ]);
+            return { ...agent, skills: webExtensions.classifyClaudeSkills(catalog), mcp: webExtensions.parseClaudeMcpList(mcpOutput) };
+        }
+        const [skillsOutput, mcpOutput] = await Promise.all([
+            probe(webExtensions.buildCodexSkillsCommand()),
+            probe('codex mcp list --json')
+        ]);
+        return { ...agent, skills: webExtensions.parseCodexSkillsOutput(skillsOutput), mcp: webExtensions.parseCodexMcpJson(mcpOutput) };
+    }));
+}
+
+// 分叉出来的 AGENT 不继承的字段（运行态、统计、队列）；其余在下面逐个列出要复制的
+function cloneMessageForFork(message) {
+    const copy = JSON.parse(JSON.stringify(message));
+    // 幂等 id 和执行中标记只属于原来那一轮
+    delete copy.clientMessageId;
+    delete copy.pending;
+    return copy;
+}
+
+async function forkWebAgentSession(ctx, state, sessionRef, messageId) {
+    if (state.agentRuns.has(sessionRef.containerName)) {
+        return { status: 409, error: '任务进行中，暂时不能分叉' };
+    }
+    const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+    const source = getWebAgentSession(history, sessionRef.agentId, { includeArchived: true });
+    if (!source || !Array.isArray(source.messages) || source.messages.length === 0) {
+        return { status: 404, error: '这个 AGENT 还没有对话，没法分叉' };
+    }
+    let copyUntil = source.messages.length;
+    let prompt = '';
+    let images = [];
+    let target = null;
+    if (messageId) {
+        const index = source.messages.findIndex(item => item && String(item.id || '') === messageId);
+        target = index >= 0 ? source.messages[index] : null;
+        if (!target || target.role !== 'user' || target.mode !== 'agent') {
+            return { status: 404, error: '没有找到这条提示词' };
+        }
+        if (target.pending === true) {
+            return { status: 409, error: '这一轮还在进行中' };
+        }
+        copyUntil = index;
+        prompt = target.content;
+        images = Array.isArray(target.images) ? target.images : [];
+    } else if (source.messages.some(item => item && item.pending === true)) {
+        return { status: 409, error: '任务进行中，暂时不能分叉' };
+    }
+    const program = getAgentRuntimeMeta(resolveEffectiveAgentPromptCommandForSession(
+        history, sessionRef.agentId, (listWebManyoyoContainers(ctx)[sessionRef.containerName] || {}).defaultCommand
+    )).agentProgram;
+    // 引擎会话：claude 用 --fork-session（带目标那一轮之前的位置）；位置找不到或其它 Agent 就退回历史注入（不精确但不丢数据）
+    let engineSessionId = '';
+    let rewindToUuid = '';
+    let conversationMode = 'history';
+    if (program === 'claude' && source.engineSessionId) {
+        try {
+            const command = webRewind.buildClaudeRecordsCommand(source.engineSessionId);
+            await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+            const records = command ? webRewind.parseClaudeRecords(await runWebContainerScript(ctx, sessionRef.containerName, command, 30000)) : [];
+            if (!target) {
+                // 从最新处分叉也要固定分叉点：否则原 AGENT 之后又聊了几轮，新 AGENT 第一轮会 fork 到原会话的最新状态
+                const lastAssistant = [...records].reverse().find(item => item.t === 'assistant');
+                if (lastAssistant && webRewind.UUID_PATTERN.test(lastAssistant.u)) {
+                    engineSessionId = source.engineSessionId;
+                    rewindToUuid = lastAssistant.u;
+                    conversationMode = 'precise';
+                }
+            } else {
+                const pick = webRewind.pickClaudeResumeAt(records, { text: target.content, timeMs: Date.parse(target.timestamp) });
+                if (pick.found && pick.uuid) {
+                    engineSessionId = source.engineSessionId;
+                    rewindToUuid = pick.uuid;
+                    conversationMode = 'precise';
+                } else if (pick.found) {
+                    // 分叉点在第一轮之前：什么都不需要记得，开新会话
+                    conversationMode = 'precise';
+                }
+            }
+        } catch (e) {
+            // 容器起不来 / 读不到记录：退回历史注入（不精确但不丢数据）
+        }
+    }
+    // 上面有 await：重新读一次，期间可能有人开始了新一轮
+    if (state.agentRuns.has(sessionRef.containerName)) {
+        return { status: 409, error: '任务进行中，暂时不能分叉' };
+    }
+    const freshHistory = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+    const freshSource = getWebAgentSession(freshHistory, sessionRef.agentId, { includeArchived: true });
+    if (!freshSource || freshSource.messages.length < copyUntil) {
+        return { status: 409, error: '对话刚刚发生了变化，请重试' };
+    }
+    const forked = createWebAgentSession(freshHistory);
+    forked.messages = freshSource.messages.slice(0, copyUntil).map(cloneMessageForFork);
+    forked.agentPromptCommand = freshSource.agentPromptCommand || '';
+    forked.model = freshSource.model || '';
+    forked.effort = freshSource.effort || '';
+    forked.firstPrompt = freshSource.firstPrompt || '';
+    forked.slashCommands = freshSource.slashCommands || null;
+    forked.engineSessionId = engineSessionId;
+    forked.rewindToUuid = rewindToUuid;
+    forked.forkPending = Boolean(engineSessionId);
+    // 标题：沿用原来的显示名加“（分叉）”，不再花钱重新生成
+    const baseTitle = freshSource.remark || freshSource.title || freshSource.autoTitle || freshSource.firstPrompt || '';
+    forked.autoTitle = baseTitle ? sessionMeta.normalizeTitle(`${Array.from(baseTitle).slice(0, 24).join('')}（分叉）`) : '';
+    forked.autoTitleTried = true;
+    saveWebSessionHistory(state.webHistoryDir, sessionRef.containerName, freshHistory);
+    return {
+        result: {
+            name: buildWebSessionKey(sessionRef.containerName, forked.agentId),
+            agentId: forked.agentId,
+            prompt,
+            images,
+            conversationMode
+        }
+    };
+}
+
+// 第一条 Agent 消息发出后与第一轮并行生成标题（像 CLI 那样）；写回前重新读一次，AGENT 被删了就放弃
+async function maybeStartAutoTitle(ctx, state, sessionRef, agentProgram, prompt) {
+    try {
+        await startAutoTitle(ctx, state, sessionRef, agentProgram, prompt);
+    } catch (e) {
+        // 调用方是 void：这里抛出去就是 unhandled rejection，会让 serve 退出。标题是锦上添花，失败静默
+    }
+}
+
+async function startAutoTitle(ctx, state, sessionRef, agentProgram, prompt) {
+    if (ctx.autoTitle === false || (agentProgram !== 'claude' && agentProgram !== 'codex')) {
+        return;
+    }
+    const agentSession = getWebAgentSession(
+        loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName),
+        sessionRef.agentId,
+        { includeArchived: true }
+    );
+    if (!agentSession || agentSession.autoTitleTried || agentSession.autoTitle || agentSession.title || agentSession.remark) {
+        return;
+    }
+    const userMessages = agentSession.messages.filter(item => item && item.role === 'user' && item.mode === 'agent');
+    if (userMessages.length !== 1) {
+        return;
+    }
+    patchWebAgentSessionState(state.webHistoryDir, sessionRef, { autoTitleTried: true });
+    const title = await runWebLightCall(ctx, state, sessionRef, agentProgram, 'title', agentLight.TITLE_RULE, agentLight.buildTitleInput(prompt), agentLight.TITLE_MAX_CHARS);
+    if (!title) {
+        return;
+    }
+    const fresh = getWebAgentSession(
+        loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName),
+        sessionRef.agentId,
+        { includeArchived: true }
+    );
+    if (fresh && !fresh.autoTitle) {
+        patchWebAgentSessionState(state.webHistoryDir, sessionRef, { autoTitle: title });
+    }
+}
+
 function appendWebAgentTraceMessage(webHistoryDir, sessionRefOrContainerName, content, extra = {}) {
     const text = String(content || '').trim();
     if (!text) {
@@ -4773,6 +5207,17 @@ try {
 `);
 }
 
+// 开头事件里就带的引擎会话 id：claude 是 system/init 的 session_id，codex 是 thread.started 的 thread_id
+function extractEarlyEngineSessionId(agentProgram, payload) {
+    if (!payload || typeof payload !== 'object') {
+        return '';
+    }
+    const id = agentProgram === 'claude' && payload.type === 'system' && payload.subtype === 'init'
+        ? payload.session_id
+        : (agentProgram === 'codex' && payload.type === 'thread.started' ? payload.thread_id : '');
+    return typeof id === 'string' && webRewind.UUID_PATTERN.test(id) ? id : '';
+}
+
 async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerName, command, options = {}) {
     const opts = options && typeof options === 'object' ? options : {};
     const sessionRef = typeof sessionRefOrContainerName === 'string'
@@ -4848,6 +5293,13 @@ async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerNa
             if (agentProgram === 'claude' || agentProgram === 'gemini' || agentProgram === 'codex' || agentProgram === 'opencode') {
                 const payload = parseJsonObjectLine(rawLine);
                 if (payload) {
+                    // claude 开头的 init 事件就带会话 id：第一轮没结束就让侧问等功能拿到它
+                    if (typeof opts.onEngineSessionId === 'function') {
+                        const earlySessionId = extractEarlyEngineSessionId(agentProgram, payload);
+                        if (earlySessionId) {
+                            try { opts.onEngineSessionId(earlySessionId); } catch (e) { /* 记不下来不影响本轮 */ }
+                        }
+                    }
                     const traceEvents = prepareStructuredTraceEvents(agentProgram, payload, structuredTraceState);
                     traceEvents.forEach(traceEvent => {
                         if (!traceEvent || !traceEvent.text) {
@@ -5540,7 +5992,7 @@ async function reconcileOrphanTurns(ctx, state) {
 // 一轮 agent 对话的完整流程（占锁 → 落盘 → 执行 → 收尾）。res 是 NDJSON 响应；
 // 排队的提示词在没有前端连接时由 createHeadlessResponse() 顶替，事件照常落盘。
 // 返回 { busy } / { error }（没开始）或 { started: true }（跑完了）
-async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessageId, res, images = []) {
+async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessageId, res, images = [], turnOptions = {}) {
     if (state.agentRuns.has(sessionRef.containerName)) {
         // 锁是容器级的：同一容器里其他 agent 会话在跑任务时同样命中这里
         return { busy: true };
@@ -5554,6 +6006,7 @@ async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessa
         userMessage = appendWebSessionMessage(state.webHistoryDir, sessionRef, 'user', prompt, {
             mode: 'agent',
             pending: true,
+            ...(turnOptions.permissionMode === 'plan' ? { planMode: true } : {}),
             ...(images.length ? { images } : {}),
             ...(clientMessageId ? { clientMessageId: clientMessageId } : {})
         });
@@ -5574,7 +6027,7 @@ async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessa
 
     let prepared = null;
     try {
-        prepared = await prepareWebAgentExecution(ctx, state, sessionRef, prompt, images);
+        prepared = await prepareWebAgentExecution(ctx, state, sessionRef, prompt, images, turnOptions);
     } catch (e) {
         releaseWebAgentRun(state, sessionRef.containerName, runState);
         removeWebSessionMessage(state.webHistoryDir, sessionRef, traceMessage && traceMessage.id);
@@ -5583,6 +6036,7 @@ async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessa
     }
 
     const { agentSession, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError, engineSessionId } = prepared;
+    void maybeStartAutoTitle(ctx, state, sessionRef, agentMeta.agentProgram, prompt);
     const traceLines = ['[执行过程]'];
     const traceEvents = [];
     let streamingReplyMessageId = '';
@@ -5759,6 +6213,10 @@ async function runWebAgentStreamTurn(ctx, state, sessionRef, prompt, clientMessa
                 agentProgram: agentMeta.agentProgram,
                 // 复用路由入口占好的那把锁，而不是另起一份运行登记
                 runState,
+                // 只在这个 AGENT 还没有引擎会话时提前记下（分叉 / 续接的轮次已经有了，不能被改写）
+                onEngineSessionId: (agentMeta.agentProgram === 'claude' || agentMeta.agentProgram === 'codex') && !agentSession.engineSessionId
+                    ? sessionId => patchWebAgentSessionState(state.webHistoryDir, sessionRef, { engineSessionId: sessionId })
+                    : undefined,
                 onEvent: handleStreamEvent
             });
         } finally {
@@ -6186,6 +6644,8 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef, preloadedHist
         agentName: agentSession.agentName,
         agentRemark: agentSession.remark || '',
         agentTitle: agentSession.title || '',
+        autoTitle: agentSession.autoTitle || '',
+        recap: agentSession.recap || null,
         firstPrompt: agentSession.firstPrompt || '',
         pinned: agentSession.pinned === true,
         containerRemark: history.remark || '',
@@ -6198,6 +6658,8 @@ function buildSessionSummary(ctx, state, containerMap, sessionRef, preloadedHist
         agentProgram: effectiveAgentProgram || '',
         resumeSupported: effectiveResumeSupported,
         model: agentSession.model || '',
+        effort: agentSession.effort || '',
+        contextUsage: agentSession.contextUsage || null,
         hostPath: applied.hostPath || '',
         containerPath: applied.containerPath || '',
         archived: agentSession.archived === true,
@@ -8226,9 +8688,22 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 }
                 const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
                 const agentSession = getWebAgentSession(history, sessionRef.agentId, { includeArchived: true });
+                const containerInfo = listWebManyoyoContainers(ctx)[sessionRef.containerName] || {};
+                const agentProgram = resolveAgentProgram(resolveEffectiveAgentPromptCommandForSession(
+                    history,
+                    sessionRef.agentId,
+                    containerInfo.defaultCommand
+                ));
+                // 只有 claude 有可透传的斜杠命令；新 AGENT 没跑过一轮也能靠 initialize 目录列出来
+                const catalog = agentProgram === 'claude'
+                    ? await fetchClaudeCommandCatalogCached(ctx, sessionRef.containerName)
+                    : [];
                 sendJson(res, 200, {
                     name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
-                    commands: sessionMeta.listUsableSlashCommands(agentSession && agentSession.slashCommands)
+                    agentProgram,
+                    commands: agentProgram === 'claude'
+                        ? sessionMeta.listSlashCommandEntries(agentSession && agentSession.slashCommands, catalog)
+                        : []
                 });
             }
         },
@@ -8260,7 +8735,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 sendJson(res, 200, {
                     name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
                     agentProgram,
-                    models
+                    // 强度列表等内部字段只给服务端用（推理强度选项），不进这个接口的返回
+                    models: models.map(({ value, label, description }) => ({ value, label, description }))
                 });
             }
         },
@@ -8308,8 +8784,216 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     sendJson(res, 400, { error: e.message || String(e) });
                     return;
                 }
-                patchWebAgentSessionState(state.webHistoryDir, sessionRef, { model });
-                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), model });
+                const patch = { model };
+                // 换模型后，新模型不支持当前强度就回到默认（下次发送不再注入）
+                const before = getWebAgentSession(loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName), sessionRef.agentId, { includeArchived: true });
+                if (before && before.effort) {
+                    const levels = await resolveEffortLevels(ctx, state, sessionRef, model);
+                    if (levels && !levels.includes(before.effort)) patch.effort = '';
+                }
+                patchWebAgentSessionState(state.webHistoryDir, sessionRef, patch);
+                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), model, effort: patch.effort !== undefined ? patch.effort : (before ? before.effort || '' : '') });
+            }
+        },
+        {
+            // 技能与 MCP（只读）：容器里装了哪个 Agent 就列哪个。claude 的 skill 来自命令目录，MCP 来自 mcp list（会真实连接，最长 30 秒）
+            method: 'GET',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/extensions$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                try {
+                    await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+                } catch (e) {
+                    sendJson(res, 400, { error: e && e.message ? e.message : '容器没有运行' });
+                    return;
+                }
+                const agents = await readWebExtensions(ctx, sessionRef.containerName);
+                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), agents });
+            }
+        },
+        {
+            // 分叉：同容器新建一个 AGENT，带着目标那一轮之前的对话（不给 messageId 就是全部）。文件不复制（同一个工作目录）
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/fork$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = toPlainObject(await readJsonBody(req));
+                const messageId = payload.messageId === undefined || payload.messageId === null ? '' : String(payload.messageId);
+                const outcome = await forkWebAgentSession(ctx, state, sessionRef, messageId);
+                if (outcome.error) {
+                    sendJson(res, outcome.status || 400, { error: outcome.error });
+                    return;
+                }
+                sendJson(res, 200, outcome.result);
+            }
+        },
+        {
+            // 侧问：带着上下文问一句，不占运行锁（主任务可以同时在跑）、不写历史、不写控制事件
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/side$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = toPlainObject(await readJsonBody(req));
+                const question = agentSide.normalizeSideQuestion(payload.question);
+                if (!question) {
+                    sendJson(res, 400, { error: '请输入要问的内容（不超过 4000 字）' });
+                    return;
+                }
+                const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                // 还没发过任何消息的 AGENT 没有历史记录：按空会话处理，不要为此创建
+                const agentSession = getWebAgentSession(history, sessionRef.agentId, { includeArchived: true }) || createEmptyWebAgentSession();
+                const containerInfo = listWebManyoyoContainers(ctx)[sessionRef.containerName] || {};
+                const agentProgram = resolveAgentProgram(resolveEffectiveAgentPromptCommandForSession(history, sessionRef.agentId, containerInfo.defaultCommand));
+                if (agentProgram !== 'claude' && agentProgram !== 'codex') {
+                    sendJson(res, 400, { error: '当前 Agent 不支持侧问' });
+                    return;
+                }
+                // 刚分叉 / 刚回退、下一轮还没发出去：引擎会话 id 还指着原来的完整会话，带上它会看到分叉点之后 / 已被回退掉的内容
+                if (agentSession.forkPending === true || agentSession.rewindToUuid) {
+                    sendJson(res, 409, { error: '刚分叉或回退过，先正常发一条消息再用侧问' });
+                    return;
+                }
+                let inFlight = sideQuestionsInFlight.get(ctx);
+                if (!inFlight) {
+                    inFlight = new Set();
+                    sideQuestionsInFlight.set(ctx, inFlight);
+                }
+                const flightKey = `${sessionRef.containerName}\u0000${sessionRef.agentId}`;
+                if (inFlight.has(flightKey)) {
+                    sendJson(res, 409, { error: '上一个侧问还在回答，请稍等' });
+                    return;
+                }
+                inFlight.add(flightKey);
+                // 客户端在容器还没就绪时就断开也要算：先登记，拿到终止函数后再补上
+                let abortSide = null;
+                let clientGone = false;
+                res.once('close', () => {
+                    if (res.writableEnded) return;
+                    clientGone = true;
+                    if (abortSide) abortSide();
+                });
+                try {
+                    await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+                    if (clientGone) {
+                        return;
+                    }
+                    const outcome = await answerWebSideQuestion(ctx, state, sessionRef, agentProgram, agentSession, question, abort => {
+                        abortSide = abort;
+                        if (clientGone) abort();
+                    });
+                    if (outcome.error) {
+                        sendJson(res, 502, { error: outcome.error });
+                    } else {
+                        sendJson(res, 200, { answer: outcome.answer });
+                    }
+                } catch (e) {
+                    sendJson(res, 500, { error: e && e.message ? e.message : '侧问失败' });
+                } finally {
+                    inFlight.delete(flightKey);
+                }
+            }
+        },
+        {
+            // 回顾：隔了很久回来时由前端调用（服务端再校验条件，避免列表接口里悄悄花钱）；force 给 /recap 用
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/recap$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = toPlainObject(await readJsonBody(req));
+                const readSession = () => getWebAgentSession(loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName), sessionRef.agentId, { includeArchived: true });
+                const agentSession = readSession();
+                const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                const containerInfo = listWebManyoyoContainers(ctx)[sessionRef.containerName] || {};
+                const agentProgram = resolveAgentProgram(resolveEffectiveAgentPromptCommandForSession(history, sessionRef.agentId, containerInfo.defaultCommand));
+                const respond = () => {
+                    const current = readSession();
+                    sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), recap: current && current.recap ? current.recap : null });
+                };
+                if (!agentSession || (agentProgram !== 'claude' && agentProgram !== 'codex') || state.agentRuns.has(sessionRef.containerName)) {
+                    respond();
+                    return;
+                }
+                const target = webRecap.shouldGenerateRecap(agentSession, ctx.nowMs(), payload.force === true);
+                if (!target) {
+                    respond();
+                    return;
+                }
+                const text = await runWebLightCall(ctx, state, sessionRef, agentProgram, 'recap', agentLight.RECAP_RULE, agentLight.buildRecapInput(target.promptText, target.replyText), agentLight.RECAP_MAX_CHARS);
+                if (text) {
+                    // 生成期间可能又发了新一轮：回复已经不是最后一条就丢掉
+                    const fresh = readSession();
+                    const latest = fresh ? webRecap.findRecapTarget(fresh.messages) : null;
+                    if (latest && latest.replyId === target.replyId) {
+                        patchWebAgentSessionState(state.webHistoryDir, sessionRef, { recap: { forMessageId: target.replyId, text, createdAt: new Date().toISOString() } });
+                    }
+                }
+                respond();
+            }
+        },
+        {
+            // 推理强度选项：来自 Agent 的模型目录（claude 的 initialize、codex 的 model/list，10 分钟缓存），找不到就是空数组（界面不显示）
+            method: 'GET',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/effort$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const agentSession = getWebAgentSession(loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName), sessionRef.agentId, { includeArchived: true });
+                const levels = (await resolveEffortLevels(ctx, state, sessionRef, agentSession ? agentSession.model : '')) || [];
+                let envDefault = '';
+                try {
+                    const env = readMergedEnv({ homeDir: ctx.homeDir || os.homedir(), dockerExecArgs: ctx.dockerExecArgs }, sessionRef.containerName);
+                    envDefault = agentEffort.isEffortValue(env.CLAUDE_CODE_EFFORT_LEVEL) ? env.CLAUDE_CODE_EFFORT_LEVEL : '';
+                } catch (e) { /* 读不到 env 就不提示 */ }
+                sendJson(res, 200, {
+                    name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
+                    levels,
+                    effort: agentSession && levels.includes(agentSession.effort) ? agentSession.effort : '',
+                    envDefault
+                });
+            }
+        },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/effort$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const payload = toPlainObject(await readJsonBody(req));
+                const effort = payload.effort === undefined || payload.effort === null ? '' : payload.effort;
+                if (effort !== '' && !agentEffort.isEffortValue(effort)) {
+                    sendJson(res, 400, { error: '推理强度不合法' });
+                    return;
+                }
+                if (effort !== '') {
+                    const agentSession = getWebAgentSession(loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName), sessionRef.agentId, { includeArchived: true });
+                    const levels = await resolveEffortLevels(ctx, state, sessionRef, agentSession ? agentSession.model : '');
+                    if (levels === null) {
+                        sendJson(res, 409, { error: '暂时取不到当前模型支持的推理强度（容器没有运行？），稍后再试' });
+                        return;
+                    }
+                    if (!levels.includes(effort)) {
+                        sendJson(res, 400, { error: '当前模型不支持这个推理强度' });
+                        return;
+                    }
+                }
+                patchWebAgentSessionState(state.webHistoryDir, sessionRef, { effort });
+                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), effort });
             }
         },
         {
@@ -8468,6 +9152,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     ...(agentClientId.value ? { clientMessageId: agentClientId.value } : {})
                 });
                 releaseAgentClaim();
+                void maybeStartAutoTitle(ctx, state, sessionRef, agentMeta.agentProgram, prompt);
                 const result = await execCommandInWebContainer(ctx, sessionRef.containerName, command, {
                     agentProgram: agentMeta.agentProgram
                 });
@@ -8518,7 +9203,9 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 if (rejectDuplicateClientMessage(res, state.webHistoryDir, sessionRef, streamClientId.value, { includeQueue: true })) {
                     return;
                 }
-                const turn = await runWebAgentStreamTurn(ctx, state, sessionRef, prompt, streamClientId.value, res, streamImages);
+                // 计划模式只对 claude 有意义；其它取值一律当没选
+                const turnOptions = payload.permissionMode === 'plan' ? { permissionMode: 'plan' } : {};
+                const turn = await runWebAgentStreamTurn(ctx, state, sessionRef, prompt, streamClientId.value, res, streamImages, turnOptions);
                 if (turn.busy) {
                     sendJson(res, 409, { error: '当前容器已有运行中的 agent 任务，请等它结束或先停止' });
                 } else if (turn.error) {
@@ -8861,6 +9548,8 @@ async function startWebServer(options) {
         dockerExecArgs: options.dockerExecArgs,
         dockerExecAsync: options.dockerExecAsync,
         nowMs: typeof options.nowMs === 'function' ? options.nowMs : Date.now,
+        // 自动标题（第一句话发出后的一次轻量模型调用）；测试里按“最后一次 exec 就是 Agent 那一轮”断言时可关掉
+        autoTitle: options.autoTitle !== false,
         retryRuntimeHeal: options.retryRuntimeHeal,
         showImagePullHint: options.showImagePullHint,
         removeContainer: options.removeContainer,
@@ -8977,6 +9666,11 @@ async function startWebServer(options) {
                 sendJson(res, 409, { error: e.message, imagePreparing: true });
                 return;
             }
+            // 镜像不存在 / 拉不到：附上结构化信息，网页用弹窗告诉用户怎么办
+            if (e && e.imageProblem) {
+                sendJson(res, 409, { error: e.message, imageProblem: e.imageProblem });
+                return;
+            }
             ctx.logger.error('http request error', {
                 method: req && req.method ? req.method : '',
                 url: redactLoginTokenInUrl(req && req.url ? req.url : ''),
@@ -9179,6 +9873,10 @@ module.exports = {
     __testing: {
         prepareStructuredTraceEvents,
         buildClaudeAgentExecCommand,
+        buildCodexAgentExecCommand,
+        extractEarlyEngineSessionId,
+        finalizeWebAgentExecution,
+        patchWebAgentSessionState,
         buildWebAgentExecCommand,
         buildContainerFileListCommand,
         extractContentDeltaFromPayload,