@xcanwin/manyoyo 5.7.2 → 5.7.4

package/lib/web/server.js

@@ -29,9 +29,14 @@ const WEB_AGENT_CONTEXT_MAX_CHARS = 6000;
 const WEB_AGENT_CONTEXT_PER_MESSAGE_MAX_CHARS = 600;
 const WEB_AUTH_COOKIE_NAME = 'manyoyo_web_auth';
 const WEB_AUTH_TTL_SECONDS = 12 * 60 * 60;
+const WEB_SESSION_KEY_SEPARATOR = '~';
+const WEB_DEFAULT_AGENT_ID = 'default';
+const WEB_DEFAULT_AGENT_NAME = 'AGENT 1';
 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_.-]*)$/;
+const SENSITIVE_CONFIG_KEY_PATTERN = /(pass(word)?|passwd|secret|token|api(?:_|-)?key|auth(?:_|-)?token|oauth(?:_|-)?token)$/i;
+const REDACTED_CONFIG_VALUE = '***';
 
 const YOLO_COMMAND_MAP = {
     claude: 'IS_SANDBOX=1 claude --dangerously-skip-permissions',
@@ -113,62 +118,113 @@ function getWebHistoryFile(webHistoryDir, containerName) {
     return path.join(webHistoryDir, `${containerName}.json`);
 }
 
+function normalizeWebAgentName(agentId, agentName) {
+    const name = typeof agentName === 'string' ? agentName.trim() : '';
+    if (name) {
+        return name;
+    }
+    if (agentId === WEB_DEFAULT_AGENT_ID) {
+        return WEB_DEFAULT_AGENT_NAME;
+    }
+    const matched = String(agentId || '').match(/^agent-(\d+)$/);
+    if (matched) {
+        return `AGENT ${matched[1]}`;
+    }
+    return String(agentId || '').trim() || WEB_DEFAULT_AGENT_NAME;
+}
+
+function createEmptyWebAgentSession(agentId, agentName) {
+    return {
+        agentId,
+        agentName: normalizeWebAgentName(agentId, agentName),
+        updatedAt: null,
+        messages: [],
+        lastResumeAt: null,
+        lastResumeOk: null,
+        lastResumeError: ''
+    };
+}
+
+function normalizeWebAgentSessionRecord(agentId, rawAgent) {
+    const source = rawAgent && typeof rawAgent === 'object' && !Array.isArray(rawAgent) ? rawAgent : {};
+    return {
+        agentId,
+        agentName: normalizeWebAgentName(agentId, source.agentName),
+        updatedAt: typeof source.updatedAt === 'string' ? source.updatedAt : null,
+        messages: Array.isArray(source.messages) ? source.messages : [],
+        lastResumeAt: typeof source.lastResumeAt === 'string' ? source.lastResumeAt : null,
+        lastResumeOk: typeof source.lastResumeOk === 'boolean' ? source.lastResumeOk : null,
+        lastResumeError: typeof source.lastResumeError === 'string' ? source.lastResumeError : ''
+    };
+}
+
+function normalizeWebHistoryRecord(containerName, rawData) {
+    const data = rawData && typeof rawData === 'object' && !Array.isArray(rawData) ? rawData : {};
+    const history = {
+        containerName,
+        updatedAt: typeof data.updatedAt === 'string' ? data.updatedAt : null,
+        agentPromptCommand: typeof data.agentPromptCommand === 'string'
+            ? data.agentPromptCommand
+            : '',
+        applied: data.applied && typeof data.applied === 'object' && !Array.isArray(data.applied)
+            ? data.applied
+            : null,
+        agents: {}
+    };
+
+    if (data.agents && typeof data.agents === 'object' && !Array.isArray(data.agents)) {
+        Object.keys(data.agents).forEach(agentId => {
+            if (!SAFE_CONTAINER_NAME_PATTERN.test(agentId)) {
+                return;
+            }
+            history.agents[agentId] = normalizeWebAgentSessionRecord(agentId, data.agents[agentId]);
+        });
+    }
+
+    if (!Object.keys(history.agents).length && Array.isArray(data.messages)) {
+        history.agents[WEB_DEFAULT_AGENT_ID] = normalizeWebAgentSessionRecord(WEB_DEFAULT_AGENT_ID, {
+            agentName: data.agentName || WEB_DEFAULT_AGENT_NAME,
+            updatedAt: typeof data.updatedAt === 'string' ? data.updatedAt : null,
+            messages: data.messages,
+            lastResumeAt: typeof data.lastResumeAt === 'string' ? data.lastResumeAt : null,
+            lastResumeOk: typeof data.lastResumeOk === 'boolean' ? data.lastResumeOk : null,
+            lastResumeError: typeof data.lastResumeError === 'string' ? data.lastResumeError : ''
+        });
+    }
+
+    return history;
+}
+
 function loadWebSessionHistory(webHistoryDir, containerName) {
     ensureWebHistoryDir(webHistoryDir);
     const filePath = getWebHistoryFile(webHistoryDir, containerName);
     if (!fs.existsSync(filePath)) {
-        return {
-            containerName,
-            updatedAt: null,
-            messages: [],
-            agentPromptCommand: '',
-            agentProgram: '',
-            resumeSupported: false,
-            lastResumeAt: null,
-            lastResumeOk: null,
-            lastResumeError: '',
-            applied: null
-        };
+        return normalizeWebHistoryRecord(containerName, {});
     }
 
     try {
-        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        return {
-            containerName,
-            updatedAt: data.updatedAt || null,
-            messages: Array.isArray(data.messages) ? data.messages : [],
-            agentPromptCommand: typeof data.agentPromptCommand === 'string'
-                ? data.agentPromptCommand
-                : '',
-            agentProgram: typeof data.agentProgram === 'string' ? data.agentProgram : '',
-            resumeSupported: data.resumeSupported === true,
-            lastResumeAt: typeof data.lastResumeAt === 'string' ? data.lastResumeAt : null,
-            lastResumeOk: typeof data.lastResumeOk === 'boolean' ? data.lastResumeOk : null,
-            lastResumeError: typeof data.lastResumeError === 'string' ? data.lastResumeError : '',
-            applied: data.applied && typeof data.applied === 'object' && !Array.isArray(data.applied)
-                ? data.applied
-                : null
-        };
+        return normalizeWebHistoryRecord(containerName, JSON.parse(fs.readFileSync(filePath, 'utf-8')));
     } catch (e) {
-        return {
-            containerName,
-            updatedAt: null,
-            messages: [],
-            agentPromptCommand: '',
-            agentProgram: '',
-            resumeSupported: false,
-            lastResumeAt: null,
-            lastResumeOk: null,
-            lastResumeError: '',
-            applied: null
-        };
+        return normalizeWebHistoryRecord(containerName, {});
     }
 }
 
 function saveWebSessionHistory(webHistoryDir, containerName, history) {
     ensureWebHistoryDir(webHistoryDir);
     const filePath = getWebHistoryFile(webHistoryDir, containerName);
-    fs.writeFileSync(filePath, JSON.stringify(history, null, 4));
+    const normalized = normalizeWebHistoryRecord(containerName, history);
+    const runtimeMeta = getAgentRuntimeMeta(normalized);
+    const defaultAgent = getWebAgentSession(normalized, WEB_DEFAULT_AGENT_ID) || createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID);
+    const legacyCompatible = {
+        ...normalized,
+        messages: Array.isArray(defaultAgent.messages) ? defaultAgent.messages : [],
+        agentProgram: runtimeMeta.agentProgram || '',
+        resumeSupported: runtimeMeta.resumeSupported === true,
+        lastResumeAt: defaultAgent.lastResumeAt || null,
+        lastResumeOk: typeof defaultAgent.lastResumeOk === 'boolean' ? defaultAgent.lastResumeOk : null,
+        lastResumeError: defaultAgent.lastResumeError || ''
+    };
+    fs.writeFileSync(filePath, JSON.stringify(legacyCompatible, null, 4));
 }
 
 function removeWebSessionHistory(webHistoryDir, containerName) {
@@ -187,10 +243,84 @@ function listWebHistorySessionNames(webHistoryDir, isValidContainerName) {
         .filter(name => isValidContainerName(name));
 }
 
-function appendWebSessionMessage(webHistoryDir, containerName, role, content, extra = {}) {
-    const history = loadWebSessionHistory(webHistoryDir, containerName);
+function buildWebSessionKey(containerName, agentId = WEB_DEFAULT_AGENT_ID) {
+    if (agentId === WEB_DEFAULT_AGENT_ID) {
+        return containerName;
+    }
+    return `${containerName}${WEB_SESSION_KEY_SEPARATOR}${agentId}`;
+}
+
+function parseWebSessionKey(sessionKey) {
+    const decoded = String(sessionKey || '').trim();
+    if (!decoded) {
+        return {
+            key: '',
+            containerName: '',
+            agentId: WEB_DEFAULT_AGENT_ID
+        };
+    }
+    const separatorIndex = decoded.indexOf(WEB_SESSION_KEY_SEPARATOR);
+    if (separatorIndex === -1) {
+        return {
+            key: decoded,
+            containerName: decoded,
+            agentId: WEB_DEFAULT_AGENT_ID
+        };
+    }
+    return {
+        key: decoded,
+        containerName: decoded.slice(0, separatorIndex),
+        agentId: decoded.slice(separatorIndex + 1) || WEB_DEFAULT_AGENT_ID
+    };
+}
+
+function getWebAgentSession(history, agentId, options = {}) {
+    const sessionHistory = history && typeof history === 'object' ? history : { agents: {} };
+    if (!sessionHistory.agents || typeof sessionHistory.agents !== 'object' || Array.isArray(sessionHistory.agents)) {
+        sessionHistory.agents = {};
+    }
+    const requestedAgentId = String(agentId || WEB_DEFAULT_AGENT_ID).trim() || WEB_DEFAULT_AGENT_ID;
+    if (sessionHistory.agents[requestedAgentId]) {
+        return sessionHistory.agents[requestedAgentId];
+    }
+    if (options.create === true) {
+        const agentSession = createEmptyWebAgentSession(requestedAgentId);
+        sessionHistory.agents[requestedAgentId] = agentSession;
+        return agentSession;
+    }
+    return null;
+}
+
+function listWebAgentSessions(history, options = {}) {
+    const sessionHistory = history && typeof history === 'object' ? history : {};
+    const agents = sessionHistory.agents && typeof sessionHistory.agents === 'object' && !Array.isArray(sessionHistory.agents)
+        ? sessionHistory.agents
+        : {};
+    const agentIds = Object.keys(agents);
+    if (!agentIds.length && options.includeSyntheticDefault === true) {
+        return [createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID)];
+    }
+    return agentIds
+        .map(agentId => agents[agentId])
+        .filter(Boolean)
+        .sort((a, b) => {
+            const orderA = a.agentId === WEB_DEFAULT_AGENT_ID ? 0 : 1;
+            const orderB = b.agentId === WEB_DEFAULT_AGENT_ID ? 0 : 1;
+            if (orderA !== orderB) {
+                return orderA - orderB;
+            }
+            return String(a.agentName || '').localeCompare(String(b.agentName || ''), 'zh-CN');
+        });
+}
+
+function appendWebSessionMessage(webHistoryDir, sessionRefOrContainerName, role, content, extra = {}) {
+    const sessionRef = typeof sessionRefOrContainerName === 'string'
+        ? { containerName: sessionRefOrContainerName, agentId: WEB_DEFAULT_AGENT_ID }
+        : sessionRefOrContainerName;
+    const history = loadWebSessionHistory(webHistoryDir, sessionRef.containerName);
+    const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true });
     const timestamp = new Date().toISOString();
-    history.messages.push({
+    agentSession.messages.push({
         id: `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
         role,
         content,
@@ -198,30 +328,22 @@ function appendWebSessionMessage(webHistoryDir, containerName, role, content, ex
         ...extra
     });
 
-    if (history.messages.length > WEB_HISTORY_MAX_MESSAGES) {
-        history.messages = history.messages.slice(-WEB_HISTORY_MAX_MESSAGES);
+    if (agentSession.messages.length > WEB_HISTORY_MAX_MESSAGES) {
+        agentSession.messages = agentSession.messages.slice(-WEB_HISTORY_MAX_MESSAGES);
     }
 
+    agentSession.updatedAt = timestamp;
     history.updatedAt = timestamp;
-    saveWebSessionHistory(webHistoryDir, containerName, history);
+    saveWebSessionHistory(webHistoryDir, sessionRef.containerName, history);
 }
 
 function setWebSessionAgentPromptCommand(webHistoryDir, containerName, agentPromptCommand) {
     const history = loadWebSessionHistory(webHistoryDir, containerName);
     history.agentPromptCommand = normalizeAgentPromptCommandTemplate(agentPromptCommand, 'agentPromptCommand');
-    const agentProgram = resolveAgentProgram(history.agentPromptCommand);
-    const resumeCommand = buildAgentResumeCommand(agentProgram);
-    history.agentProgram = agentProgram || '';
-    history.resumeSupported = Boolean(resumeCommand);
-    if (!history.resumeSupported) {
-        history.lastResumeAt = null;
-        history.lastResumeOk = null;
-        history.lastResumeError = '';
-    }
     saveWebSessionHistory(webHistoryDir, containerName, history);
 }
 
-function patchWebSessionAgentState(webHistoryDir, containerName, patch) {
+function patchWebSessionHistory(webHistoryDir, containerName, patch) {
     const history = loadWebSessionHistory(webHistoryDir, containerName);
     if (!patch || typeof patch !== 'object') {
         return history;
@@ -233,6 +355,37 @@ function patchWebSessionAgentState(webHistoryDir, containerName, patch) {
     return history;
 }
 
+function patchWebAgentSessionState(webHistoryDir, sessionRefOrContainerName, patch) {
+    const sessionRef = typeof sessionRefOrContainerName === 'string'
+        ? { containerName: sessionRefOrContainerName, agentId: WEB_DEFAULT_AGENT_ID }
+        : sessionRefOrContainerName;
+    const history = loadWebSessionHistory(webHistoryDir, sessionRef.containerName);
+    const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true });
+    if (!patch || typeof patch !== 'object') {
+        return agentSession;
+    }
+    Object.keys(patch).forEach(key => {
+        agentSession[key] = patch[key];
+    });
+    saveWebSessionHistory(webHistoryDir, sessionRef.containerName, history);
+    return agentSession;
+}
+
+function createWebAgentSession(history) {
+    const sessionHistory = history && typeof history === 'object' ? history : { agents: {} };
+    if (!sessionHistory.agents || typeof sessionHistory.agents !== 'object' || Array.isArray(sessionHistory.agents)) {
+        sessionHistory.agents = {};
+    }
+    let agentIndex = 2;
+    while (sessionHistory.agents[`agent-${agentIndex}`]) {
+        agentIndex += 1;
+    }
+    const agentId = `agent-${agentIndex}`;
+    const agentSession = createEmptyWebAgentSession(agentId, `AGENT ${agentIndex}`);
+    sessionHistory.agents[agentId] = agentSession;
+    return agentSession;
+}
+
 function stripAnsi(text) {
     if (typeof text !== 'string') return '';
     return text.replace(/\x1b\[[0-9;]*m/g, '');
@@ -1124,27 +1277,28 @@ function prepareCodexTraceEvent(payload) {
     });
 }
 
-async function prepareWebAgentExecution(ctx, state, containerName, prompt) {
-    const history = loadWebSessionHistory(state.webHistoryDir, containerName);
+async function prepareWebAgentExecution(ctx, state, sessionRef, prompt) {
+    const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+    const agentSession = getWebAgentSession(history, sessionRef.agentId, { create: true });
     const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
     if (normalizedTemplate !== history.agentPromptCommand) {
         history.agentPromptCommand = normalizedTemplate;
-        saveWebSessionHistory(state.webHistoryDir, containerName, history);
+        saveWebSessionHistory(state.webHistoryDir, sessionRef.containerName, history);
     }
     if (!isAgentPromptCommandEnabled(history.agentPromptCommand)) {
         throw new Error('当前会话未配置 agentPromptCommand');
     }
 
-    await ensureWebContainer(ctx, state, containerName);
+    await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
     const agentMeta = getAgentRuntimeMeta(history);
-    const hasPriorConversation = hasAgentConversationHistory(history);
+    const hasPriorConversation = hasAgentConversationHistory(agentSession);
     let resumeAttempted = false;
     let resumeSucceeded = false;
     let resumeError = '';
 
     if (hasPriorConversation && agentMeta.resumeSupported && agentMeta.resumeCommand) {
         resumeAttempted = true;
-        const resumeResult = await execCommandInWebContainer(ctx, containerName, agentMeta.resumeCommand);
+        const resumeResult = await execCommandInWebContainer(ctx, sessionRef.containerName, agentMeta.resumeCommand);
         if (resumeResult.exitCode === 0) {
             resumeSucceeded = true;
         } else {
@@ -1154,12 +1308,13 @@ async function prepareWebAgentExecution(ctx, state, containerName, prompt) {
 
     const effectivePrompt = resumeSucceeded
         ? prompt
-        : buildAgentPromptWithHistory(history, prompt);
+        : buildAgentPromptWithHistory(agentSession, prompt);
     const command = buildWebAgentExecCommand(history.agentPromptCommand, effectivePrompt, agentMeta.agentProgram);
     const contextMode = resumeSucceeded ? 'resume' : (hasPriorConversation ? 'history-injected' : 'first-turn');
 
     return {
         history,
+        agentSession,
         agentMeta,
         command,
         contextMode,
@@ -1169,8 +1324,8 @@ async function prepareWebAgentExecution(ctx, state, containerName, prompt) {
     };
 }
 
-function finalizeWebAgentExecution(state, containerName, history, agentMeta, meta, result) {
-    appendWebSessionMessage(state.webHistoryDir, containerName, 'assistant', result.output, {
+function finalizeWebAgentExecution(state, sessionRef, agentSession, agentMeta, meta, result) {
+    appendWebSessionMessage(state.webHistoryDir, sessionRef, 'assistant', result.output, {
         exitCode: result.exitCode,
         mode: 'agent',
         contextMode: meta.contextMode,
@@ -1178,21 +1333,19 @@ function finalizeWebAgentExecution(state, containerName, history, agentMeta, met
         resumeSucceeded: meta.resumeSucceeded,
         interrupted: result.interrupted === true
     });
-    patchWebSessionAgentState(state.webHistoryDir, containerName, {
-        agentProgram: agentMeta.agentProgram,
-        resumeSupported: agentMeta.resumeSupported,
-        lastResumeAt: meta.resumeAttempted ? new Date().toISOString() : history.lastResumeAt || null,
-        lastResumeOk: meta.resumeAttempted ? meta.resumeSucceeded : history.lastResumeOk,
-        lastResumeError: meta.resumeAttempted ? (meta.resumeSucceeded ? '' : meta.resumeError) : history.lastResumeError || ''
+    patchWebAgentSessionState(state.webHistoryDir, sessionRef, {
+        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 || '')
     });
 }
 
-function appendWebAgentTraceMessage(webHistoryDir, containerName, content, extra = {}) {
+function appendWebAgentTraceMessage(webHistoryDir, sessionRefOrContainerName, content, extra = {}) {
     const text = String(content || '').trim();
     if (!text) {
         return;
     }
-    appendWebSessionMessage(webHistoryDir, containerName, 'assistant', text, {
+    appendWebSessionMessage(webHistoryDir, sessionRefOrContainerName, 'assistant', text, {
         mode: 'agent',
         streamTrace: true,
         ...extra
@@ -1300,6 +1453,59 @@ function toPlainObject(value) {
     return value;
 }
 
+function isSensitiveConfigKey(key) {
+    const normalized = String(key || '').trim();
+    return Boolean(normalized) && SENSITIVE_CONFIG_KEY_PATTERN.test(normalized);
+}
+
+function redactConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => redactConfigValue(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return REDACTED_CONFIG_VALUE;
+    }
+    return redactConfigObject(value);
+}
+
+function redactConfigObject(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => redactConfigValue(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    Object.entries(toPlainObject(value)).forEach(([key, item]) => {
+        if (isSensitiveConfigKey(key)) {
+            result[key] = redactConfigValue(item);
+            return;
+        }
+        if (Array.isArray(item)) {
+            result[key] = item.map(entry => redactConfigValue(entry));
+            return;
+        }
+        if (item && typeof item === 'object') {
+            result[key] = redactConfigObject(item);
+            return;
+        }
+        result[key] = item;
+    });
+    return result;
+}
+
+function buildSafeWebConfigSnapshot(snapshot, ctx) {
+    const parsed = snapshot && snapshot.parseError ? {} : toPlainObject(snapshot && snapshot.parsed);
+    return {
+        path: snapshot && snapshot.path ? snapshot.path : path.resolve(getDefaultWebConfigPath()),
+        parsed: redactConfigObject(parsed),
+        defaults: redactConfigObject(buildConfigDefaults(ctx, parsed)),
+        parseError: snapshot && snapshot.parseError ? snapshot.parseError : null,
+        editable: false,
+        notice: 'Web 端仅显示脱敏后的配置摘要；敏感值请在本地 manyoyo.json 中维护。'
+    };
+}
+
 function pickFirstString() {
     for (let i = 0; i < arguments.length; i += 1) {
         const value = arguments[i];
@@ -1705,23 +1911,29 @@ function buildCreateRuntime(ctx, state, payload) {
     const hasConfigPorts = hasOwn(config, 'ports');
 
     const requestName = pickFirstString(requestOptions.containerName, body.name);
-    let containerName = pickFirstString(requestName, config.containerName);
+    let containerName = pickFirstString(requestName, runConfig.containerName, config.containerName);
     if (!containerName) {
         containerName = `my-${ctx.formatDate()}`;
     }
     containerName = resolveNowTemplate(containerName, ctx.formatDate);
     validateContainerNameStrict(containerName);
 
-    const hostPath = pickFirstString(requestOptions.hostPath, config.hostPath, ctx.hostPath);
+    const hostPath = pickFirstString(requestOptions.hostPath, runConfig.hostPath, config.hostPath, ctx.hostPath);
     if (typeof ctx.validateHostPath === 'function') {
         ctx.validateHostPath(hostPath);
     } else {
         validateWebHostPath(hostPath);
     }
 
-    const containerPath = pickFirstString(requestOptions.containerPath, config.containerPath, ctx.containerPath, hostPath) || hostPath;
-    const imageName = pickFirstString(requestOptions.imageName, config.imageName, ctx.imageName);
-    const imageVersion = pickFirstString(requestOptions.imageVersion, config.imageVersion, ctx.imageVersion);
+    const containerPath = pickFirstString(
+        requestOptions.containerPath,
+        runConfig.containerPath,
+        config.containerPath,
+        ctx.containerPath,
+        hostPath
+    ) || hostPath;
+    const imageName = pickFirstString(requestOptions.imageName, runConfig.imageName, config.imageName, ctx.imageName);
+    const imageVersion = pickFirstString(requestOptions.imageVersion, runConfig.imageVersion, config.imageVersion, ctx.imageVersion);
 
     if (!/^[A-Za-z0-9][A-Za-z0-9._/:-]*$/.test(imageName)) {
         throw new Error(`imageName 非法: ${imageName}`);
@@ -1730,7 +1942,7 @@ function buildCreateRuntime(ctx, state, payload) {
 
     let contModeArgs = Array.isArray(ctx.contModeArgs) ? ctx.contModeArgs.slice() : [];
     let containerMode = '';
-    const modeValue = pickFirstString(requestOptions.containerMode, config.containerMode);
+    const modeValue = pickFirstString(requestOptions.containerMode, runConfig.containerMode, config.containerMode);
     if (modeValue) {
         const mode = resolveContainerModeArgs(modeValue);
         containerMode = mode.mode;
@@ -1739,16 +1951,24 @@ function buildCreateRuntime(ctx, state, payload) {
 
     const shellPrefix = hasOwn(requestOptions, 'shellPrefix')
         ? String(requestOptions.shellPrefix || '')
-        : (hasOwn(config, 'shellPrefix') ? String(config.shellPrefix || '') : String(ctx.execCommandPrefix || ''));
+        : (hasOwn(runConfig, 'shellPrefix')
+            ? String(runConfig.shellPrefix || '')
+            : (hasOwn(config, 'shellPrefix') ? String(config.shellPrefix || '') : String(ctx.execCommandPrefix || '')));
     let shell = hasOwn(requestOptions, 'shell')
         ? String(requestOptions.shell || '')
-        : (hasOwn(config, 'shell') ? String(config.shell || '') : String(ctx.execCommand || ''));
+        : (hasOwn(runConfig, 'shell')
+            ? String(runConfig.shell || '')
+            : (hasOwn(config, 'shell') ? String(config.shell || '') : String(ctx.execCommand || '')));
     const shellSuffix = hasOwn(requestOptions, 'shellSuffix')
         ? String(requestOptions.shellSuffix || '')
-        : (hasOwn(config, 'shellSuffix') ? String(config.shellSuffix || '') : String(ctx.execCommandSuffix || ''));
+        : (hasOwn(runConfig, 'shellSuffix')
+            ? String(runConfig.shellSuffix || '')
+            : (hasOwn(config, 'shellSuffix') ? String(config.shellSuffix || '') : String(ctx.execCommandSuffix || '')));
     const yolo = hasOwn(requestOptions, 'yolo')
         ? String(requestOptions.yolo || '')
-        : (hasOwn(config, 'yolo') ? String(config.yolo || '') : '');
+        : (hasOwn(runConfig, 'yolo')
+            ? String(runConfig.yolo || '')
+            : (hasOwn(config, 'yolo') ? String(config.yolo || '') : ''));
     const yoloCommand = resolveYoloCommand(yolo);
     if (yoloCommand) {
         shell = yoloCommand;
@@ -1769,19 +1989,23 @@ function buildCreateRuntime(ctx, state, payload) {
     const resumeSupported = Boolean(buildAgentResumeCommand(agentProgram));
 
     let containerEnvs = Array.isArray(ctx.containerEnvs) ? ctx.containerEnvs.slice() : [];
-    if (hasRequestEnv || hasRequestEnvFile || hasConfigEnv || hasConfigEnvFile) {
+    const hasRunEnv = hasOwn(runConfig, 'env');
+    const hasRunEnvFile = hasOwn(runConfig, 'envFile');
+    if (hasRequestEnv || hasRequestEnvFile || hasRunEnv || hasRunEnvFile || hasConfigEnv || hasConfigEnvFile) {
         const configEnv = normalizeEnvMap(config.env, 'config.env');
+        const runEnv = normalizeEnvMap(runConfig.env, runName ? `runs.${runName}.env` : 'run.env');
         const requestEnv = hasRequestEnv ? normalizeEnvMap(requestOptions.env, 'createOptions.env') : {};
-        const mergedEnv = { ...configEnv, ...requestEnv };
+        const mergedEnv = { ...configEnv, ...runEnv, ...requestEnv };
         const envArgs = [];
         Object.entries(mergedEnv).forEach(([key, value]) => {
             const parsed = parseEnvEntry(`${key}=${value}`);
             envArgs.push('--env', `${parsed.key}=${parsed.value}`);
         });
 
-        const envFileList = hasRequestEnvFile
-            ? normalizeStringArray(requestOptions.envFile, 'createOptions.envFile')
-            : normalizeStringArray(config.envFile, 'config.envFile');
+        const envFileList = []
+            .concat(normalizeStringArray(config.envFile, 'config.envFile'))
+            .concat(normalizeStringArray(runConfig.envFile, runName ? `runs.${runName}.envFile` : 'run.envFile'))
+            .concat(hasRequestEnvFile ? normalizeStringArray(requestOptions.envFile, 'createOptions.envFile') : []);
         const envFileArgs = [];
         envFileList.forEach(filePath => {
             envFileArgs.push(...parseEnvFileToArgs(filePath));
@@ -1791,10 +2015,12 @@ function buildCreateRuntime(ctx, state, payload) {
     }
 
     let containerVolumes = Array.isArray(ctx.containerVolumes) ? ctx.containerVolumes.slice() : [];
-    if (hasRequestVolumes || hasConfigVolumes) {
-        const volumeList = hasRequestVolumes
-            ? normalizeStringArray(requestOptions.volumes, 'createOptions.volumes')
-            : normalizeStringArray(config.volumes, 'config.volumes');
+    const hasRunVolumes = hasOwn(runConfig, 'volumes');
+    if (hasRequestVolumes || hasRunVolumes || hasConfigVolumes) {
+        const volumeList = []
+            .concat(normalizeStringArray(config.volumes, 'config.volumes'))
+            .concat(normalizeStringArray(runConfig.volumes, runName ? `runs.${runName}.volumes` : 'run.volumes'))
+            .concat(hasRequestVolumes ? normalizeStringArray(requestOptions.volumes, 'createOptions.volumes') : []);
         containerVolumes = [];
         volumeList.forEach(volume => {
             containerVolumes.push('--volume', normalizeVolume(volume));
@@ -1802,10 +2028,12 @@ function buildCreateRuntime(ctx, state, payload) {
     }
 
     let containerPorts = Array.isArray(ctx.containerPorts) ? ctx.containerPorts.slice() : [];
-    if (hasRequestPorts || hasConfigPorts) {
-        const portList = hasRequestPorts
-            ? normalizeStringArray(requestOptions.ports, 'createOptions.ports')
-            : normalizeStringArray(config.ports, 'config.ports');
+    const hasRunPorts = hasOwn(runConfig, 'ports');
+    if (hasRequestPorts || hasRunPorts || hasConfigPorts) {
+        const portList = []
+            .concat(normalizeStringArray(config.ports, 'config.ports'))
+            .concat(normalizeStringArray(runConfig.ports, runName ? `runs.${runName}.ports` : 'run.ports'))
+            .concat(hasRequestPorts ? normalizeStringArray(requestOptions.ports, 'createOptions.ports') : []);
         containerPorts = [];
         portList.forEach(port => {
             containerPorts.push('--publish', port);
@@ -1905,7 +2133,7 @@ function listWebManyoyoContainers(ctx) {
     return map;
 }
 
-async function ensureWebContainer(ctx, state, containerInput) {
+async function ensureWebContainer(ctx, state, containerInput, messageSessionRef = null) {
     const runtime = typeof containerInput === 'string'
         ? buildStaticContainerRuntime(ctx, containerInput)
         : containerInput;
@@ -1937,14 +2165,24 @@ async function ensureWebContainer(ctx, state, containerInput) {
         }
 
         await ctx.waitForContainerReady(runtime.containerName);
-        appendWebSessionMessage(state.webHistoryDir, runtime.containerName, 'system', `容器 ${runtime.containerName} 已创建并启动。`);
+        appendWebSessionMessage(
+            state.webHistoryDir,
+            messageSessionRef || runtime.containerName,
+            'system',
+            `容器 ${runtime.containerName} 已创建并启动。`
+        );
         return;
     }
 
     const status = ctx.getContainerStatus(runtime.containerName);
     if (status !== 'running') {
         ctx.dockerExecArgs(['start', runtime.containerName], { stdio: 'pipe' });
-        appendWebSessionMessage(state.webHistoryDir, runtime.containerName, 'system', `容器 ${runtime.containerName} 已启动。`);
+        appendWebSessionMessage(
+            state.webHistoryDir,
+            messageSessionRef || runtime.containerName,
+            'system',
+            `容器 ${runtime.containerName} 已启动。`
+        );
     }
 }
 
@@ -2008,24 +2246,29 @@ async function execCommandInWebContainer(ctx, containerName, command, options =
     });
 }
 
-async function execAgentInWebContainerStream(ctx, state, containerName, command, options = {}) {
+async function execAgentInWebContainerStream(ctx, state, sessionRefOrContainerName, command, options = {}) {
     const opts = options && typeof options === 'object' ? options : {};
+    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', containerName, '/bin/bash', '-lc', command],
+        ['exec', sessionRef.containerName, '/bin/bash', '-lc', command],
         { stdio: ['ignore', 'pipe', 'pipe'] }
     );
 
     const runState = {
-        containerName,
+        containerName: sessionRef.containerName,
+        sessionKey,
         process,
         command,
         startedAt: new Date().toISOString(),
         stopping: false
     };
-    state.agentRuns.set(containerName, runState);
+    state.agentRuns.set(sessionRef.containerName, runState);
 
     return await new Promise((resolve, reject) => {
         const MAX_RAW_OUTPUT_CHARS = 32 * 1024 * 1024;
@@ -2124,11 +2367,11 @@ async function execAgentInWebContainerStream(ctx, state, containerName, command,
         });
 
         process.on('error', error => {
-            state.agentRuns.delete(containerName);
+            state.agentRuns.delete(sessionRef.containerName);
             reject(error);
         });
         process.on('close', code => {
-            state.agentRuns.delete(containerName);
+            state.agentRuns.delete(sessionRef.containerName);
             if (stdoutPending) {
                 emitStdoutTraceLine(stdoutPending);
                 stdoutPending = '';
@@ -2216,6 +2459,15 @@ function sendHtml(res, statusCode, html, extraHeaders = {}) {
     res.end(html);
 }
 
+function sendRedirect(res, statusCode, location, extraHeaders = {}) {
+    res.writeHead(statusCode, {
+        Location: location,
+        'Cache-Control': 'no-store',
+        ...extraHeaders
+    });
+    res.end('');
+}
+
 function decodeSessionName(encoded) {
     try {
         return decodeURIComponent(encoded);
@@ -2224,30 +2476,51 @@ function decodeSessionName(encoded) {
     }
 }
 
-function getValidSessionName(ctx, res, encodedName) {
-    const containerName = decodeSessionName(encodedName);
-    if (!ctx.isValidContainerName(containerName)) {
-        sendJson(res, 400, { error: `containerName 非法: ${containerName}` });
+function getValidSessionRef(ctx, res, encodedName) {
+    const parsed = parseWebSessionKey(decodeSessionName(encodedName));
+    if (!ctx.isValidContainerName(parsed.containerName)) {
+        sendJson(res, 400, { error: `containerName 非法: ${parsed.containerName}` });
         return null;
     }
-    return containerName;
+    if (!SAFE_CONTAINER_NAME_PATTERN.test(parsed.agentId)) {
+        sendJson(res, 400, { error: `agentId 非法: ${parsed.agentId}` });
+        return null;
+    }
+    return parsed;
 }
 
-function buildSessionSummary(ctx, state, containerMap, name) {
-    const history = loadWebSessionHistory(state.webHistoryDir, name);
+function buildSessionSummary(ctx, state, containerMap, sessionRef) {
+    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 agentMeta = getAgentRuntimeMeta(history);
-    const latestMessage = history.messages.length ? history.messages[history.messages.length - 1] : null;
-    const containerInfo = containerMap[name] || {};
-    const updatedAt = history.updatedAt || (latestMessage && latestMessage.timestamp) || containerInfo.createdAt || null;
+    const agentSession = getWebAgentSession(history, agentId)
+        || (agentId === WEB_DEFAULT_AGENT_ID ? createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID) : null);
+    if (!agentSession) {
+        return null;
+    }
+    const latestMessage = agentSession.messages.length ? agentSession.messages[agentSession.messages.length - 1] : null;
+    const containerInfo = containerMap[containerName] || {};
+    const applied = history.applied && typeof history.applied === 'object' && !Array.isArray(history.applied)
+        ? history.applied
+        : buildSessionFallbackApplied(ctx, state, containerName, history, {
+            status: containerInfo.status || 'history'
+        });
+    const updatedAt = agentSession.updatedAt || history.updatedAt || (latestMessage && latestMessage.timestamp) || containerInfo.createdAt || null;
     return {
-        name,
+        name: buildWebSessionKey(containerName, agentId),
+        containerName,
+        agentId,
+        agentName: agentSession.agentName,
         status: containerInfo.status || 'history',
         image: containerInfo.image || '',
         updatedAt,
-        messageCount: history.messages.length,
+        messageCount: agentSession.messages.length,
         agentEnabled: isAgentPromptCommandEnabled(history.agentPromptCommand),
         agentProgram: agentMeta.agentProgram,
-        resumeSupported: agentMeta.resumeSupported
+        resumeSupported: agentMeta.resumeSupported,
+        hostPath: applied.hostPath || '',
+        containerPath: applied.containerPath || ''
     };
 }
 
@@ -2255,9 +2528,8 @@ function buildSessionFallbackApplied(ctx, state, name, history, summary) {
     const snapshot = readWebConfigSnapshot(state.webConfigPath);
     const defaults = buildConfigDefaults(ctx, snapshot.parseError ? {} : snapshot.parsed);
     const effectiveAgentPromptCommand = history.agentPromptCommand || defaults.agentPromptCommand || '';
-    const effectiveAgentProgram = history.agentProgram || resolveAgentProgram(effectiveAgentPromptCommand) || '';
-    const effectiveResumeSupported = history.resumeSupported === true
-        || Boolean(buildAgentResumeCommand(effectiveAgentProgram));
+    const effectiveAgentProgram = resolveAgentProgram(effectiveAgentPromptCommand) || '';
+    const effectiveResumeSupported = Boolean(buildAgentResumeCommand(effectiveAgentProgram));
     const defaultCommand = buildDefaultCommand(
         defaults.shellPrefix,
         defaults.shell,
@@ -2287,24 +2559,34 @@ function buildSessionFallbackApplied(ctx, state, name, history, summary) {
 }
 
 function buildSessionDetail(ctx, state, containerMap, name) {
-    const history = loadWebSessionHistory(state.webHistoryDir, name);
+    const sessionRef = typeof name === 'string' ? parseWebSessionKey(name) : name;
+    const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
     const normalizedTemplate = normalizeAgentPromptCommandTemplate(history.agentPromptCommand, 'agentPromptCommand');
-    const summary = buildSessionSummary(ctx, state, containerMap, name);
-    const latestMessage = history.messages.length ? history.messages[history.messages.length - 1] : null;
+    const summary = buildSessionSummary(ctx, state, containerMap, sessionRef);
+    const agentSession = getWebAgentSession(history, sessionRef.agentId)
+        || (sessionRef.agentId === WEB_DEFAULT_AGENT_ID ? createEmptyWebAgentSession(WEB_DEFAULT_AGENT_ID) : null);
+    const latestMessage = agentSession && agentSession.messages.length
+        ? agentSession.messages[agentSession.messages.length - 1]
+        : null;
     const applied = history.applied && typeof history.applied === 'object' && !Array.isArray(history.applied)
         ? history.applied
-        : buildSessionFallbackApplied(ctx, state, name, history, summary);
+        : buildSessionFallbackApplied(ctx, state, sessionRef.containerName, history, summary || {});
+
+    if (!summary || !agentSession) {
+        return null;
+    }
 
     return {
         ...summary,
+        agentName: agentSession.agentName,
         latestRole: latestMessage && latestMessage.role ? String(latestMessage.role) : '',
         latestTimestamp: latestMessage && latestMessage.timestamp ? latestMessage.timestamp : summary.updatedAt,
         agentPromptCommand: normalizedTemplate || '',
-        agentProgram: history.agentProgram || summary.agentProgram || '',
-        resumeSupported: history.resumeSupported === true || summary.resumeSupported === true,
-        lastResumeAt: history.lastResumeAt || null,
-        lastResumeOk: typeof history.lastResumeOk === 'boolean' ? history.lastResumeOk : null,
-        lastResumeError: history.lastResumeError || '',
+        agentProgram: summary.agentProgram || '',
+        resumeSupported: summary.resumeSupported === true,
+        lastResumeAt: agentSession.lastResumeAt || null,
+        lastResumeOk: typeof agentSession.lastResumeOk === 'boolean' ? agentSession.lastResumeOk : null,
+        lastResumeError: agentSession.lastResumeError || '',
         applied
     };
 }
@@ -2563,6 +2845,12 @@ function bindTerminalWebSocket(ctx, state, ws, containerName, cols, rows) {
 }
 
 async function handleWebAuthRoutes(req, res, pathname, ctx, state) {
+    if (req.method === 'GET' && pathname === '/favicon.ico') {
+        res.writeHead(204, { 'Cache-Control': 'no-store' });
+        res.end();
+        return true;
+    }
+
     if (req.method === 'GET' && pathname === '/auth/login') {
         sendHtml(res, 200, loadTemplate('login.html'));
         return true;
@@ -2625,6 +2913,10 @@ function sendWebUnauthorized(res, pathname) {
         sendJson(res, 401, { error: 'UNAUTHORIZED' });
         return;
     }
+    if (pathname === '/' || pathname === '') {
+        sendRedirect(res, 302, '/auth/login', { 'Set-Cookie': getWebAuthClearCookie() });
+        return;
+    }
     sendHtml(
         res,
         401,
@@ -2645,19 +2937,58 @@ async function handleWebApi(req, res, pathname, ctx, state) {
     const routes = [
         {
             method: 'GET',
-            match: currentPath => currentPath === '/api/config' ? [] : null,
+            match: currentPath => currentPath === '/api/fs/directories' ? [] : null,
             handler: async () => {
-                const snapshot = readWebConfigSnapshot(state.webConfigPath);
-                const defaults = buildConfigDefaults(ctx, snapshot.parseError ? {} : snapshot.parsed);
+                const requestUrl = new URL(req.url || '/api/fs/directories', 'http://localhost');
+                const requestedPath = expandHomeAliasPath(String(requestUrl.searchParams.get('path') || '').trim() || os.homedir());
+                const requestedBasePath = expandHomeAliasPath(String(requestUrl.searchParams.get('basePath') || '').trim());
+                const realPath = fs.realpathSync(requestedPath);
+                if (!fs.statSync(realPath).isDirectory()) {
+                    sendJson(res, 400, { error: `目录不存在: ${realPath}` });
+                    return;
+                }
+
+                let realBasePath = '';
+                if (requestedBasePath) {
+                    realBasePath = fs.realpathSync(requestedBasePath);
+                    if (!fs.statSync(realBasePath).isDirectory()) {
+                        sendJson(res, 400, { error: `basePath 不是目录: ${realBasePath}` });
+                        return;
+                    }
+                    const relativeToBase = path.relative(realBasePath, realPath);
+                    if (relativeToBase.startsWith('..') || path.isAbsolute(relativeToBase)) {
+                        sendJson(res, 400, { error: '目录超出 basePath 范围' });
+                        return;
+                    }
+                }
+
+                const parentPath = realBasePath
+                    ? (realPath === realBasePath ? '' : path.dirname(realPath))
+                    : (realPath === path.parse(realPath).root ? '' : path.dirname(realPath));
+                const entries = fs.readdirSync(realPath, { withFileTypes: true })
+                    .filter(entry => entry && entry.isDirectory())
+                    .map(entry => ({
+                        name: entry.name,
+                        path: path.join(realPath, entry.name)
+                    }))
+                    .sort((a, b) => a.name.localeCompare(b.name, 'zh-CN'));
+
                 sendJson(res, 200, {
-                    path: snapshot.path,
-                    raw: snapshot.raw,
-                    parsed: snapshot.parseError ? null : snapshot.parsed,
-                    parseError: snapshot.parseError,
-                    defaults
+                    currentPath: realPath,
+                    basePath: realBasePath || '',
+                    parentPath,
+                    entries
                 });
             }
         },
+        {
+            method: 'GET',
+            match: currentPath => currentPath === '/api/config' ? [] : null,
+            handler: async () => {
+                const snapshot = readWebConfigSnapshot(state.webConfigPath);
+                sendJson(res, 200, buildSafeWebConfigSnapshot(snapshot, ctx));
+            }
+        },
         {
             method: 'PUT',
             match: currentPath => currentPath === '/api/config' ? [] : null,
@@ -2699,7 +3030,15 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 ]);
 
                 const sessions = Array.from(names)
-                    .map(name => buildSessionSummary(ctx, state, containerMap, name))
+                    .flatMap(name => {
+                        const history = loadWebSessionHistory(state.webHistoryDir, name);
+                        return listWebAgentSessions(history, { includeSyntheticDefault: true })
+                            .map(agentSession => buildSessionSummary(ctx, state, containerMap, {
+                                containerName: name,
+                                agentId: agentSession.agentId
+                            }))
+                            .filter(Boolean);
+                    })
                     .sort((a, b) => {
                         const timeA = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
                         const timeB = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
@@ -2724,44 +3063,70 @@ async function handleWebApi(req, res, pathname, ctx, state) {
 
                 await ensureWebContainer(ctx, state, runtime);
                 setWebSessionAgentPromptCommand(state.webHistoryDir, runtime.containerName, runtime.agentPromptCommand);
-                patchWebSessionAgentState(state.webHistoryDir, runtime.containerName, {
+                patchWebSessionHistory(state.webHistoryDir, runtime.containerName, {
                     applied: runtime.applied
                 });
                 sendJson(res, 200, { name: runtime.containerName, applied: runtime.applied });
             }
         },
+        {
+            method: 'POST',
+            match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agents$/),
+            handler: async match => {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
+                    return;
+                }
+                const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                const agentSession = createWebAgentSession(history);
+                saveWebSessionHistory(state.webHistoryDir, sessionRef.containerName, history);
+                sendJson(res, 200, {
+                    name: buildWebSessionKey(sessionRef.containerName, agentSession.agentId),
+                    containerName: sessionRef.containerName,
+                    agentId: agentSession.agentId,
+                    agentName: agentSession.agentName
+                });
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/messages$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
-                const history = loadWebSessionHistory(state.webHistoryDir, containerName);
-                sendJson(res, 200, { name: containerName, messages: history.messages });
+                const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                const agentSession = getWebAgentSession(history, sessionRef.agentId)
+                    || createEmptyWebAgentSession(sessionRef.agentId);
+                sendJson(res, 200, {
+                    name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
+                    containerName: sessionRef.containerName,
+                    agentId: sessionRef.agentId,
+                    messages: agentSession.messages
+                });
             }
         },
         {
             method: 'GET',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/detail$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
                 const containerMap = listWebManyoyoContainers(ctx);
-                const detail = buildSessionDetail(ctx, state, containerMap, containerName);
-                sendJson(res, 200, { name: containerName, detail });
+                const detail = buildSessionDetail(ctx, state, containerMap, sessionRef);
+                sendJson(res, 200, { name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId), detail });
             }
         },
         {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/run$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
@@ -2772,12 +3137,12 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     return;
                 }
 
-                await ensureWebContainer(ctx, state, containerName);
-                appendWebSessionMessage(state.webHistoryDir, containerName, 'user', command);
-                const result = await execCommandInWebContainer(ctx, containerName, command);
+                await ensureWebContainer(ctx, state, sessionRef.containerName, sessionRef);
+                appendWebSessionMessage(state.webHistoryDir, sessionRef, 'user', command);
+                const result = await execCommandInWebContainer(ctx, sessionRef.containerName, command);
                 appendWebSessionMessage(
                     state.webHistoryDir,
-                    containerName,
+                    sessionRef,
                     'assistant',
                     result.output,
                     { exitCode: result.exitCode }
@@ -2789,8 +3154,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
@@ -2803,21 +3168,21 @@ async function handleWebApi(req, res, pathname, ctx, state) {
 
                 let prepared = null;
                 try {
-                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                    prepared = await prepareWebAgentExecution(ctx, state, sessionRef, prompt);
                 } catch (e) {
                     sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
                     return;
                 }
 
-                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
-                appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
+                const { agentSession, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
+                appendWebSessionMessage(state.webHistoryDir, sessionRef, 'user', prompt, {
                     mode: 'agent',
                     contextMode
                 });
-                const result = await execCommandInWebContainer(ctx, containerName, command, {
+                const result = await execCommandInWebContainer(ctx, sessionRef.containerName, command, {
                     agentProgram: agentMeta.agentProgram
                 });
-                finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                finalizeWebAgentExecution(state, sessionRef, agentSession, agentMeta, {
                     contextMode,
                     resumeAttempted,
                     resumeSucceeded,
@@ -2837,8 +3202,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stream$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
@@ -2848,23 +3213,23 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     sendJson(res, 400, { error: 'prompt 不能为空' });
                     return;
                 }
-                if (state.agentRuns.has(containerName)) {
+                if (state.agentRuns.has(sessionRef.containerName)) {
                     sendJson(res, 409, { error: '当前会话已有运行中的 agent 任务' });
                     return;
                 }
 
                 let prepared = null;
                 try {
-                    prepared = await prepareWebAgentExecution(ctx, state, containerName, prompt);
+                    prepared = await prepareWebAgentExecution(ctx, state, sessionRef, prompt);
                 } catch (e) {
                     sendJson(res, 400, { error: e && e.message ? e.message : 'Agent 执行准备失败' });
                     return;
                 }
 
-                const { history, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
+                const { agentSession, agentMeta, command, contextMode, resumeAttempted, resumeSucceeded, resumeError } = prepared;
                 const traceLines = ['[执行过程]'];
                 const traceEvents = [];
-                appendWebSessionMessage(state.webHistoryDir, containerName, 'user', prompt, {
+                appendWebSessionMessage(state.webHistoryDir, sessionRef, 'user', prompt, {
                     mode: 'agent',
                     contextMode
                 });
@@ -2876,7 +3241,8 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 });
                 sendNdjson(res, {
                     type: 'meta',
-                    containerName,
+                    containerName: sessionRef.containerName,
+                    sessionName: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId),
                     contextMode,
                     resumeAttempted,
                     resumeSucceeded,
@@ -2890,7 +3256,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                 }
 
                 try {
-                    const result = await execAgentInWebContainerStream(ctx, state, containerName, command, {
+                    const result = await execAgentInWebContainerStream(ctx, state, sessionRef, command, {
                         agentProgram: agentMeta.agentProgram,
                         onEvent: event => {
                             if (event && event.type === 'trace' && event.text) {
@@ -2903,14 +3269,14 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                         }
                     });
                     traceLines.push(result.interrupted === true ? '[任务] 已停止' : '[任务] 已完成');
-                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                    appendWebAgentTraceMessage(state.webHistoryDir, sessionRef, traceLines.join('\n'), {
                         traceEvents,
                         contextMode,
                         resumeAttempted,
                         resumeSucceeded,
                         interrupted: result.interrupted === true
                     });
-                    finalizeWebAgentExecution(state, containerName, history, agentMeta, {
+                    finalizeWebAgentExecution(state, sessionRef, agentSession, agentMeta, {
                         contextMode,
                         resumeAttempted,
                         resumeSucceeded,
@@ -2927,7 +3293,7 @@ async function handleWebApi(req, res, pathname, ctx, state) {
                     });
                 } catch (e) {
                     traceLines.push(`[错误] ${e && e.message ? e.message : 'Agent 执行失败'}`);
-                    appendWebAgentTraceMessage(state.webHistoryDir, containerName, traceLines.join('\n'), {
+                    appendWebAgentTraceMessage(state.webHistoryDir, sessionRef, traceLines.join('\n'), {
                         traceEvents,
                         contextMode,
                         resumeAttempted,
@@ -2947,11 +3313,11 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/agent\/stop$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
-                const stopped = stopWebAgentRun(state, containerName);
+                const stopped = stopWebAgentRun(state, sessionRef.containerName);
                 if (!stopped) {
                     sendJson(res, 404, { error: '当前会话没有运行中的 agent 任务' });
                     return;
@@ -2963,30 +3329,45 @@ async function handleWebApi(req, res, pathname, ctx, state) {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/remove$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
-                if (ctx.containerExists(containerName)) {
-                    ctx.removeContainer(containerName);
-                    appendWebSessionMessage(state.webHistoryDir, containerName, 'system', `容器 ${containerName} 已删除。`);
+                if (ctx.containerExists(sessionRef.containerName)) {
+                    ctx.removeContainer(sessionRef.containerName);
+                    appendWebSessionMessage(state.webHistoryDir, sessionRef, 'system', `容器 ${sessionRef.containerName} 已删除。`);
                 }
 
-                sendJson(res, 200, { removed: true, name: containerName });
+                sendJson(res, 200, { removed: true, name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId) });
             }
         },
         {
             method: 'POST',
             match: currentPath => currentPath.match(/^\/api\/sessions\/([^/]+)\/remove-with-history$/),
             handler: async match => {
-                const containerName = getValidSessionName(ctx, res, match[1]);
-                if (!containerName) {
+                const sessionRef = getValidSessionRef(ctx, res, match[1]);
+                if (!sessionRef) {
                     return;
                 }
 
-                removeWebSessionHistory(state.webHistoryDir, containerName);
-                sendJson(res, 200, { removedHistory: true, name: containerName });
+                const history = loadWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                if (history.agents && typeof history.agents === 'object') {
+                    if (sessionRef.agentId === WEB_DEFAULT_AGENT_ID) {
+                        delete history.agents[WEB_DEFAULT_AGENT_ID];
+                    } else {
+                        delete history.agents[sessionRef.agentId];
+                    }
+                }
+                if (!Object.keys(history.agents || {}).length && !ctx.containerExists(sessionRef.containerName)) {
+                    removeWebSessionHistory(state.webHistoryDir, sessionRef.containerName);
+                } else {
+                    saveWebSessionHistory(state.webHistoryDir, sessionRef.containerName, history);
+                }
+                sendJson(res, 200, {
+                    removedHistory: true,
+                    name: buildWebSessionKey(sessionRef.containerName, sessionRef.agentId)
+                });
             }
         }
     ];
@@ -3204,9 +3585,13 @@ async function startWebServer(options) {
             return;
         }
 
-        const containerName = decodeSessionName(terminalMatch[1]);
-        if (!ctx.isValidContainerName(containerName)) {
-            sendWebSocketUpgradeError(socket, 400, `containerName 非法: ${containerName}`);
+        const sessionRef = parseWebSessionKey(decodeSessionName(terminalMatch[1]));
+        if (!ctx.isValidContainerName(sessionRef.containerName)) {
+            sendWebSocketUpgradeError(socket, 400, `containerName 非法: ${sessionRef.containerName}`);
+            return;
+        }
+        if (!SAFE_CONTAINER_NAME_PATTERN.test(sessionRef.agentId)) {
+            sendWebSocketUpgradeError(socket, 400, `agentId 非法: ${sessionRef.agentId}`);
             return;
         }
 
@@ -3220,11 +3605,11 @@ async function startWebServer(options) {
             url.searchParams.get('rows')
         );
 
-        ensureWebContainer(ctx, state, containerName)
+        ensureWebContainer(ctx, state, sessionRef.containerName)
             .then(() => {
                 wsServer.handleUpgrade(req, socket, head, ws => {
                     wsServer.emit('connection', ws, req, {
-                        containerName,
+                        containerName: sessionRef.containerName,
                         cols,
                         rows
                     });