@xcanwin/manyoyo 5.7.3 → 5.7.4

package/lib/web/server.js

@@ -29,6 +29,9 @@ 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_.-]*)$/;
@@ -115,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) {
@@ -189,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,
@@ -200,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;
@@ -235,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, '');
@@ -1126,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 {
@@ -1156,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,
@@ -1171,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,
@@ -1180,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
@@ -1982,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;
@@ -2014,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} 已启动。`
+        );
     }
 }
 
@@ -2085,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;
@@ -2201,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 = '';
@@ -2310,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;
+    }
+    if (!SAFE_CONTAINER_NAME_PATTERN.test(parsed.agentId)) {
+        sendJson(res, 400, { error: `agentId 非法: ${parsed.agentId}` });
         return null;
     }
-    return containerName;
+    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 || ''
     };
 }
 
@@ -2341,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,
@@ -2373,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
     };
 }
@@ -2739,6 +2935,52 @@ async function handleWebApi(req, res, pathname, ctx, state) {
         }
     }
     const routes = [
+        {
+            method: 'GET',
+            match: currentPath => currentPath === '/api/fs/directories' ? [] : null,
+            handler: async () => {
+                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, {
+                    currentPath: realPath,
+                    basePath: realBasePath || '',
+                    parentPath,
+                    entries
+                });
+            }
+        },
         {
             method: 'GET',
             match: currentPath => currentPath === '/api/config' ? [] : null,
@@ -2788,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;
@@ -2813,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;
                 }
 
@@ -2861,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 }
@@ -2878,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;
                 }
 
@@ -2892,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,
@@ -2926,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;
                 }
 
@@ -2937,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
                 });
@@ -2965,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,
@@ -2979,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) {
@@ -2992,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,
@@ -3016,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,
@@ -3036,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;
@@ -3052,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)
+                });
             }
         }
     ];
@@ -3293,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;
         }
 
@@ -3309,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
                     });