@yeaft/webchat-agent 1.0.414 → 1.0.416

package/connection/index.js

@@ -3,6 +3,7 @@ import ctx from '../context.js';
 import { sendToServer, parseMessage } from './buffer.js';
 import { startAgentHeartbeat, stopAgentHeartbeat, scheduleReconnect } from './heartbeat.js';
 import { handleMessage } from './message-router.js';
+import { cleanupTerminalsForDisconnect } from '../terminal.js';
 
 export function resetConnectionTransport() {
   ctx.sessionKey = null;
@@ -35,6 +36,7 @@ export function connect(WebSocketImpl = WebSocket) {
     console.log(`Disallowed tools: ${ctx.CONFIG.disallowedTools.join(', ')}`);
   }
 
+  const previousSocket = ctx.ws;
   const socket = new WebSocketImpl(url, {
     // Match server's permessage-deflate config (bounded memory,
     // skip compression for small frames). The `ws` library handles
@@ -46,6 +48,12 @@ export function connect(WebSocketImpl = WebSocket) {
       threshold: 1024
     }
   });
+  if (previousSocket && previousSocket !== socket) {
+    const closedTerminals = cleanupTerminalsForDisconnect();
+    if (closedTerminals > 0) {
+      console.log(`[PTY] Closed ${closedTerminals} terminal(s) before Agent transport replacement`);
+    }
+  }
   ctx.ws = socket;
 
   socket.on('open', () => {
@@ -99,6 +107,10 @@ export function connect(WebSocketImpl = WebSocket) {
     ctx.sessionKey = null;
     ctx.pendingAuthTempId = null;
     stopAgentHeartbeat();
+    const closedTerminals = cleanupTerminalsForDisconnect();
+    if (closedTerminals > 0) {
+      console.log(`[PTY] Closed ${closedTerminals} terminal(s) after Agent transport disconnect`);
+    }
 
     if (code === 1008) {
       console.error('Authentication failed. Check AGENT_SECRET configuration.');

package/index.js

@@ -160,7 +160,7 @@ async function detectCapabilities() {
   // agent build can speak plaintext WS frames. New servers see this and
   // flip `agent.encryptOutbound = false`, stopping outbound encryption
   // to this peer. Old servers ignore the unknown capability token.
-  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', SAFE_REMOTE_UPGRADE_CAPABILITY, 'work_center', 'work_center_message_v2', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch'];
+  const capabilities = ['background_tasks', 'file_editor', 'ping_session', 'plaintext-ok', 'workbench_session_routes', SAFE_REMOTE_UPGRADE_CAPABILITY, 'work_center', 'work_center_message_v2', 'session_history_search', 'session_history_outline', 'session_history_window_prefetch'];
   if (process.platform === 'linux') capabilities.push('work_item_attachments');
   const pty = await loadNodePty();
   if (pty) capabilities.push('terminal');

package/local-runtime/agent/container-manager.js

@@ -0,0 +1,189 @@
+import { spawn } from 'node:child_process';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+
+export const DEFAULT_AGENT_IMAGE = 'ghcr.io/yeaft/yeaft-web-code-agent-agent:dev';
+const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,63}$/;
+
+export class ContainerAgentError extends Error {
+  constructor(code, message = code) {
+    super(message);
+    this.name = 'ContainerAgentError';
+    this.code = code;
+  }
+}
+
+export function normalizeContainerAgentName(name) {
+  const value = String(name || '').trim();
+  if (!NAME_PATTERN.test(value)) throw new ContainerAgentError('CONTAINER_AGENT_INVALID_NAME');
+  return value;
+}
+
+export function containerNameForAgent(name) {
+  return `yeaft-agent-${normalizeContainerAgentName(name)}`;
+}
+
+export async function runDocker(args, { spawnImpl = spawn, allowFailure = false, stdout = 'pipe' } = {}) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawnImpl('docker', args, {
+      stdio: ['ignore', stdout, 'pipe'],
+      windowsHide: true,
+    });
+    const output = [];
+    const errors = [];
+    child.stdout?.on('data', chunk => output.push(chunk));
+    child.stderr?.on('data', chunk => errors.push(chunk));
+    child.once('error', error => reject(new ContainerAgentError('CONTAINER_AGENT_DOCKER_UNAVAILABLE', error.message)));
+    child.once('close', code => {
+      const result = {
+        code: code ?? 1,
+        stdout: Buffer.concat(output).toString('utf8').trim(),
+        stderr: Buffer.concat(errors).toString('utf8').trim(),
+      };
+      if (result.code === 0 || allowFailure) resolvePromise(result);
+      else reject(new ContainerAgentError('CONTAINER_AGENT_DOCKER_FAILED', result.stderr || `docker ${args[0]} failed`));
+    });
+  });
+}
+
+export async function writeAgentSecretFile(path, secret) {
+  const value = String(secret || '').trim();
+  if (!value) throw new ContainerAgentError('CONTAINER_AGENT_SECRET_REQUIRED');
+  const absolute = resolve(path);
+  await mkdir(dirname(absolute), { recursive: true, mode: 0o700 });
+  await writeFile(absolute, `${value}\n`, { mode: 0o600 });
+  await chmod(absolute, 0o600);
+  return absolute;
+}
+
+export function buildCreateArgs({
+  name,
+  serverUrl,
+  secretFile,
+  image = DEFAULT_AGENT_IMAGE,
+  dataVolume,
+  workspaceVolume,
+  restart = 'unless-stopped',
+}) {
+  const agentName = normalizeContainerAgentName(name);
+  if (!String(serverUrl || '').match(/^wss?:\/\//)) {
+    throw new ContainerAgentError('CONTAINER_AGENT_INVALID_SERVER_URL');
+  }
+  if (!secretFile) throw new ContainerAgentError('CONTAINER_AGENT_SECRET_REQUIRED');
+  const containerName = containerNameForAgent(agentName);
+  const safeImage = String(image || '').trim();
+  if (!safeImage || safeImage.startsWith('-')) throw new ContainerAgentError('CONTAINER_AGENT_INVALID_IMAGE');
+  return [
+    'create', '--name', containerName,
+    '--label', 'io.yeaft.container-agent=true',
+    '--label', `io.yeaft.agent-name=${agentName}`,
+    '--restart', restart,
+    '--init',
+    '--mount', `type=volume,src=${dataVolume || `${containerName}-data`},dst=/home/yeaft/.yeaft`,
+    '--mount', `type=volume,src=${workspaceVolume || `${containerName}-workspace`},dst=/workspace`,
+    '--mount', `type=bind,src=${resolve(secretFile)},dst=/run/yeaft-host-secret,readonly`,
+    '--env', `SERVER_URL=${serverUrl}`,
+    '--env', `AGENT_NAME=${agentName}`,
+    '--env', 'AGENT_SECRET_FILE=/run/yeaft-host-secret',
+    '--env', 'YEAFT_DIR=/home/yeaft/.yeaft',
+    '--env', 'WORK_DIR=/workspace',
+    safeImage,
+  ];
+}
+
+/**
+ * Verify that the Docker client can reach a daemon before the Server advertises
+ * container Agent lifecycle support.
+ *
+ * @param {object} options runDocker overrides used by tests and alternate runtimes
+ * @returns {Promise<{serverVersion: string|null}>}
+ */
+export async function checkContainerAgentRuntime(options = {}) {
+  const result = await runDocker(['version', '--format', '{{.Server.Version}}'], options);
+  return { serverVersion: result.stdout || null };
+}
+
+export async function inspectContainerAgent(name, options = {}) {
+  const result = await runDocker([
+    'inspect', '--format', '{{json .State}}', containerNameForAgent(name),
+  ], { ...options, allowFailure: true });
+  if (result.code !== 0) {
+    if (/no such (object|container)/i.test(result.stderr)) {
+      return { exists: false, status: 'absent', running: false };
+    }
+    throw new ContainerAgentError('CONTAINER_AGENT_DOCKER_FAILED', result.stderr || 'docker inspect failed');
+  }
+  try {
+    const state = JSON.parse(result.stdout);
+    return {
+      exists: true,
+      status: state.Status || 'unknown',
+      running: state.Running === true,
+      startedAt: state.StartedAt || null,
+      error: state.Error || null,
+    };
+  } catch {
+    throw new ContainerAgentError('CONTAINER_AGENT_INVALID_DOCKER_RESPONSE');
+  }
+}
+
+export async function createContainerAgent(options, runtime = {}) {
+  const current = await inspectContainerAgent(options.name, runtime);
+  if (current.exists) throw new ContainerAgentError('CONTAINER_AGENT_ALREADY_EXISTS');
+  const containerName = containerNameForAgent(options.name);
+  await runDocker(buildCreateArgs(options), runtime);
+  try {
+    await runDocker(['start', containerName], runtime);
+  } catch (error) {
+    await runDocker(['rm', '-f', containerName], { ...runtime, allowFailure: true });
+    throw error;
+  }
+  return inspectContainerAgent(options.name, runtime);
+}
+
+export async function startContainerAgent(name, runtime = {}) {
+  await runDocker(['start', containerNameForAgent(name)], runtime);
+  return inspectContainerAgent(name, runtime);
+}
+
+export async function stopContainerAgent(name, runtime = {}) {
+  await runDocker(['stop', '--time', '10', containerNameForAgent(name)], runtime);
+  return inspectContainerAgent(name, runtime);
+}
+
+function isMissingDockerVolume(stderr) {
+  return /no such volume/i.test(String(stderr || ''));
+}
+
+export async function removeContainerAgent(name, { removeVolumes = true, ...runtime } = {}) {
+  const containerName = containerNameForAgent(name);
+  const current = await inspectContainerAgent(name, runtime);
+  if (current.exists) await runDocker(['rm', '-f', containerName], runtime);
+  if (removeVolumes) {
+    for (const volume of [`${containerName}-data`, `${containerName}-workspace`]) {
+      const result = await runDocker(['volume', 'rm', volume], {
+        ...runtime,
+        allowFailure: true,
+      });
+      if (result.code !== 0 && !isMissingDockerVolume(result.stderr)) {
+        throw new ContainerAgentError(
+          'CONTAINER_AGENT_DOCKER_FAILED',
+          result.stderr || `docker volume rm ${volume} failed`,
+        );
+      }
+    }
+  }
+  return { exists: false, status: 'absent', running: false };
+}
+
+export async function logsContainerAgent(name, { follow = false, ...runtime } = {}) {
+  const args = ['logs'];
+  if (follow) args.push('--follow');
+  args.push(containerNameForAgent(name));
+  return runDocker(args, { ...runtime, stdout: follow ? 'inherit' : 'pipe' });
+}
+
+export async function readSecretInput({ secret, secretFile }) {
+  if (secretFile) return (await readFile(resolve(secretFile), 'utf8')).trim();
+  return String(secret || '').trim();
+}

package/local-runtime/server/client-protocol.js

@@ -0,0 +1,14 @@
+export const WORKBENCH_ROUTE_PROTOCOL = 1;
+
+/**
+ * Apply the explicit browser protocol hello to one Server-owned client record.
+ * Unknown or omitted fields leave legacy defaults unchanged.
+ */
+export function applyClientHello(client, message) {
+  if (!client || message?.type !== 'client_hello') return false;
+  if (message.plaintextOk === true) client.encryptOutbound = false;
+  if (message.workbenchRouteProtocol === WORKBENCH_ROUTE_PROTOCOL) {
+    client.workbenchRouteProtocol = WORKBENCH_ROUTE_PROTOCOL;
+  }
+  return true;
+}

package/local-runtime/server/context.js

@@ -29,8 +29,9 @@ export const directoryCache = new Map();
 export const DIR_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
 export const DIR_CACHE_MAX_SIZE = 500;
 
-// ★ Phase 5: File Tab state storage
-// key: `${userId}:${agentId}` → { files: [{path}], activeIndex, timestamp }
+// Workbench Files tab state. Route-aware writers use
+// `${userId}:${routeKey}\0${workspaceGeneration}`; legacy pairs keep the
+// historical `${userId}:${agentId}` key.
 export const userFileTabs = new Map();
 
 // Preview file cache for binary file preview (Office/PDF/Image)

package/local-runtime/server/handlers/agent-file-terminal.js

@@ -1,130 +1,200 @@
 import { randomUUID } from 'crypto';
-import { previewFiles, webClients } from '../context.js';
+import { CONFIG } from '../config.js';
+import { agents, previewFiles, webClients } from '../context.js';
 import {
-  sendToWebClient, forwardToClients,
-  setCachedDir, invalidateParentDirCache, clearAgentDirCache
+  sendToAgent,
+  sendToWebClient,
+  setCachedDir,
+  invalidateParentDirCache,
+  clearAgentDirCache,
 } from '../ws-utils.js';
+import {
+  currentWorkbenchWorkspaceGeneration,
+  workbenchRouteKeyFromConversationId,
+} from '../workbench-route.js';
+import {
+  consumeWorkbenchRequest,
+  deleteWorkbenchTerminalOwner,
+  getWorkbenchTerminalOwner,
+  registerWorkbenchTerminalOwner,
+} from '../workbench-correlation.js';
 
-/**
- * Handle file, terminal, and git messages from agent.
- * Types: terminal_created, terminal_output, terminal_closed, terminal_error,
- *        file_content, file_saved, directory_listing, file_op_result,
- *        git_status_result, git_diff_result, git_op_result, file_search_result
- */
-export async function handleAgentFileTerminal(agentId, agent, msg) {
-  switch (msg.type) {
-    // Terminal messages (forward to web clients)
-    case 'terminal_created':
-    case 'terminal_output':
-    case 'terminal_closed':
-    case 'terminal_error': {
-      const targetClient = msg._requestClientId ? webClients.get(msg._requestClientId) : null;
-      const targetMatchesUser = !msg._requestUserId || targetClient?.userId === msg._requestUserId;
-      if (targetClient?.authenticated && targetMatchesUser) {
-        const { _requestClientId, _requestUserId, ...cleanMsg } = msg;
-        await sendToWebClient(targetClient, cleanMsg);
-        break;
-      }
-      const { _requestClientId, ...fallbackMsg } = msg;
-      await forwardToClients(agentId, msg.conversationId, fallbackMsg);
-      break;
-    }
+function stripAgentRouting(msg) {
+  const {
+    _requestClientId: _ignoredClientId,
+    _requestUserId: _ignoredUserId,
+    _workbenchRequestId: _ignoredRequestId,
+    workbenchRouteKey: _ignoredRouteKey,
+    workbenchWorkspaceGeneration: _ignoredGeneration,
+    ...visible
+  } = msg || {};
+  return visible;
+}
 
-    // File operation messages
-    case 'file_content': {
-      let fwdMsg = { ...msg, agentId };
-      if (msg.binary) {
-        // Binary file: cache on server, forward fileId instead of base64 content
-        const fileId = randomUUID();
-        const token = randomUUID();
-        const filename = msg.filePath.split('/').pop() || 'file';
-        previewFiles.set(fileId, {
-          buffer: Buffer.from(msg.content, 'base64'),
-          mimeType: msg.mimeType,
-          filename,
-          createdAt: Date.now(),
-          token
-        });
-        console.log(`[Server] Cached binary preview: fileId=${fileId}, mime=${msg.mimeType}, path=${msg.filePath}`);
-        fwdMsg = {
-          type: 'file_content',
-          agentId,
+function pendingResponse(agentId, msg, pending) {
+  const { requestId: _agentRequestId, ...visible } = stripAgentRouting(msg);
+  return {
+    ...visible,
+    agentId,
+    conversationId: pending.conversationId,
+    ...(pending.publicRequestId ? { requestId: pending.publicRequestId } : {}),
+    workbenchRouteKey: pending.routeKey,
+    workbenchWorkspaceGeneration: pending.workspaceGeneration,
+  };
+}
+
+async function sendToPendingClient(agentId, msg, pending) {
+  const client = webClients.get(pending?.clientId);
+  if (!client?.authenticated || client.userId !== pending?.userId) return false;
+  await sendToWebClient(client, pendingResponse(agentId, msg, pending));
+  return true;
+}
+
+async function forwardLegacyResponse(agentId, msg) {
+  const visible = { ...stripAgentRouting(msg), agentId };
+  const agent = agents.get(agentId);
+  const conversation = agent?.conversations?.get?.(visible.conversationId);
+  const ownerId = conversation?.userId || agent?.ownerId || null;
+  for (const [, client] of webClients) {
+    if (!client?.authenticated) continue;
+    const allowed = CONFIG.skipAuth
+      || (ownerId ? client.userId === ownerId : client.role === 'admin');
+    if (allowed) await sendToWebClient(client, visible);
+  }
+}
+
+function cacheBinaryPreview(msg) {
+  const fileId = randomUUID();
+  const token = randomUUID();
+  const filename = msg.filePath.split('/').pop() || 'file';
+  previewFiles.set(fileId, {
+    buffer: Buffer.from(msg.content, 'base64'),
+    mimeType: msg.mimeType,
+    filename,
+    createdAt: Date.now(),
+    token,
+  });
+  const { content: _binaryContent, ...projected } = msg;
+  return {
+    ...projected,
+    binary: true,
+    fileId,
+    previewToken: token,
+  };
+}
+
+async function handleTerminalResponse(agentId, msg, routeKey) {
+  const terminalId = msg.terminalId || null;
+  if (msg.type === 'terminal_created') {
+    const pending = consumeWorkbenchRequest({
+      agentId,
+      requestId: msg._workbenchRequestId,
+      responseType: msg.type,
+      routeKey,
+    });
+    if (!pending) {
+      const agentRecord = agents.get(agentId);
+      if (agentRecord && terminalId && msg.workbenchWorkspaceGeneration) {
+        await sendToAgent(agentRecord, {
+          type: 'terminal_close',
           conversationId: msg.conversationId,
-          requestId: msg.requestId,
-          _requestUserId: msg._requestUserId,
-          _requestClientId: msg._requestClientId,
-          filePath: msg.filePath,
-          requestedFilePath: msg.requestedFilePath,
-          binary: true,
-          fileId,
-          previewToken: token,
-          mimeType: msg.mimeType
-        };
-      } else {
-        console.log(`[Server] Forwarding file_content to clients, conv=${msg.conversationId}, path=${msg.filePath}`);
-      }
-      const targetClient = fwdMsg._requestClientId ? webClients.get(fwdMsg._requestClientId) : null;
-      const targetMatchesUser = !fwdMsg._requestUserId || targetClient?.userId === fwdMsg._requestUserId;
-      if (targetClient?.authenticated && targetMatchesUser) {
-        const { _requestClientId, _requestUserId, ...cleanMsg } = fwdMsg;
-        await sendToWebClient(targetClient, cleanMsg);
-      } else {
-        const { _requestClientId, ...fallbackMsg } = fwdMsg;
-        await forwardToClients(agentId, msg.conversationId, fallbackMsg);
+          terminalId,
+          workbenchRouteKey: routeKey,
+          workbenchWorkspaceGeneration: msg.workbenchWorkspaceGeneration,
+        });
       }
-      break;
+      return;
     }
-
-    case 'file_saved': {
-      // Phase 4: 文件保存后失效父目录缓存
-      invalidateParentDirCache(agentId, msg.filePath);
-      const fwdMsg = { ...msg, agentId };
-      const targetClient = msg._requestClientId ? webClients.get(msg._requestClientId) : null;
-      const targetMatchesUser = !msg._requestUserId || targetClient?.userId === msg._requestUserId;
-      if (targetClient?.authenticated && targetMatchesUser) {
-        const { _requestClientId, _requestUserId, ...cleanMsg } = fwdMsg;
-        await sendToWebClient(targetClient, cleanMsg);
-      } else {
-        const { _requestClientId, ...fallbackMsg } = fwdMsg;
-        await forwardToClients(agentId, msg.conversationId, fallbackMsg);
-      }
-      break;
+    if (pending.routeKey !== routeKey || pending.terminalId !== terminalId) {
+      deleteWorkbenchTerminalOwner(agentId, pending.terminalId);
+      return;
     }
+    if (msg.success !== false) registerWorkbenchTerminalOwner({ ...pending, terminalId });
+    else deleteWorkbenchTerminalOwner(agentId, terminalId);
+    await sendToPendingClient(agentId, msg, pending);
+    return;
+  }
 
-    case 'directory_listing': {
-      // Phase 4: 缓存目录列表结果
-      if (msg.dirPath && msg.entries && !msg.error) {
-        setCachedDir(agentId, msg.dirPath, msg.entries);
-      }
-      // 优先定向发送给请求者
-      const dirTargetClientId = msg._requestClientId;
-      if (dirTargetClientId) {
-        const targetClient = webClients.get(dirTargetClientId);
-        if (targetClient?.authenticated) {
-          const { _requestClientId, ...cleanMsg } = msg;
-          await sendToWebClient(targetClient, cleanMsg);
-          break;
-        }
-      }
-      await forwardToClients(agentId, msg.conversationId, msg);
-      break;
-    }
+  // Create errors carry the one-shot create correlation even though a
+  // terminal-id reservation already exists. Consume and release it first.
+  if (msg.type === 'terminal_error' && msg._workbenchRequestId) {
+    const pending = consumeWorkbenchRequest({
+      agentId,
+      requestId: msg._workbenchRequestId,
+      responseType: msg.type,
+      routeKey,
+    });
+    if (pending?.terminalId) deleteWorkbenchTerminalOwner(agentId, pending.terminalId);
+    if (pending?.routeKey === routeKey) await sendToPendingClient(agentId, msg, pending);
+    return;
+  }
+
+  const owner = terminalId ? getWorkbenchTerminalOwner(agentId, terminalId) : null;
+  if (owner) {
+    if (owner.routeKey !== routeKey) return;
+    await sendToPendingClient(agentId, msg, owner);
+    if (msg.type === 'terminal_closed') deleteWorkbenchTerminalOwner(agentId, terminalId);
+  }
+}
 
-    case 'file_op_result':
-      // Phase 4: 文件创建/删除/移动 — 清空该 agent 的所有目录缓存
-      clearAgentDirCache(agentId);
-      await forwardToClients(agentId, msg.conversationId, msg);
-      break;
+async function handleOneShotResponse(agentId, msg, routeKey) {
+  const pending = consumeWorkbenchRequest({
+    agentId,
+    requestId: msg._workbenchRequestId,
+    responseType: msg.type,
+    routeKey,
+  });
+  if (!pending) return;
+  const currentGeneration = currentWorkbenchWorkspaceGeneration({
+    route: pending.route,
+    userId: pending.userId,
+    role: pending.role,
+  });
+  if (!currentGeneration || currentGeneration !== pending.workspaceGeneration) return;
+  const projected = msg.type === 'file_content' && msg.binary
+    ? cacheBinaryPreview(msg)
+    : msg;
+  await sendToPendingClient(agentId, projected, pending);
+}
 
-    case 'git_status_result':
-    case 'git_diff_result':
-    case 'git_op_result':
-    case 'file_search_result':
-      await forwardToClients(agentId, msg.conversationId, msg);
-      break;
+/**
+ * Handle file, terminal, and git messages from an Agent. Route-scoped replies
+ * are delivered only through Server-owned correlations. Agent-supplied client
+ * or user ids never select a browser recipient.
+ */
+export async function handleAgentFileTerminal(agentId, agent, rawMsg) {
+  const msg = rawMsg || {};
+  const routeKey = workbenchRouteKeyFromConversationId(msg.conversationId, agentId);
+  const terminalTypes = new Set([
+    'terminal_created', 'terminal_output', 'terminal_closed', 'terminal_error',
+  ]);
+  const oneShotTypes = new Set([
+    'file_content', 'file_saved', 'directory_listing', 'file_op_result',
+    'git_status_result', 'git_diff_result', 'git_op_result', 'file_search_result',
+  ]);
+  if (!terminalTypes.has(msg.type) && !oneShotTypes.has(msg.type)) return false;
 
-    default:
-      return false; // Not handled
+  if (msg.type === 'file_saved') invalidateParentDirCache(agentId, msg.filePath);
+  if (msg.type === 'file_op_result') clearAgentDirCache(agentId);
+  if (msg.type === 'directory_listing' && msg.dirPath && msg.entries && !msg.error) {
+    setCachedDir(agentId, msg.dirPath, msg.entries);
   }
-  return true; // Handled
+
+  if (routeKey) {
+    if (terminalTypes.has(msg.type)) await handleTerminalResponse(agentId, msg, routeKey);
+    else await handleOneShotResponse(agentId, msg, routeKey);
+    return true;
+  }
+
+  // `_workbench:` is reserved for Server-authored route conversations. An
+  // invalid or cross-Agent value is not a legacy conversation.
+  if (typeof msg.conversationId === 'string' && msg.conversationId.startsWith('_workbench:')) {
+    return true;
+  }
+
+  const projected = msg.type === 'file_content' && msg.binary
+    ? cacheBinaryPreview(msg)
+    : msg;
+  await forwardLegacyResponse(agentId, projected);
+  return true;
 }

package/local-runtime/server/handlers/agent-output.js

@@ -53,6 +53,9 @@ function syncYeaftSessionMetadata(agentId, agent, event) {
 
   if (event.type === 'session_list_updated') {
     const rows = Array.isArray(event.sessions) ? event.sessions : [];
+    agent.yeaftSessions = new Map(rows
+      .filter(session => session?.id)
+      .map(session => [session.id, { ...session }]));
     try {
       if (ownerId) {
         reconcileAuthoritativeSessionSnapshot(ownerId, agentId, rows);

package/local-runtime/server/handlers/client-misc.js

@@ -2,6 +2,7 @@ import { agents, userFileTabs } from '../context.js';
 import {
   sendToWebClient, forwardToAgent, broadcastAgentList
 } from '../ws-utils.js';
+import { resolveWorkbenchRequest } from '../workbench-route.js';
 
 // Only Agents that explicitly advertise the package-replacement-safe updater
 // may receive remote upgrade commands. Version thresholds are insufficient:
@@ -73,11 +74,18 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
 
     // File Tab 状态保存/恢复
     case 'update_file_tabs': {
-      if (client.userId && client.currentAgent) {
-        const key = `${client.userId}:${client.currentAgent}`;
+      const ftAgentId = msg.agentId || client.currentAgent;
+      if (client.userId && ftAgentId) {
+        if (!await checkAgentAccess(ftAgentId)) break;
+        const resolved = resolveWorkbenchRequest(client, msg, ftAgentId);
+        if (!resolved) break;
+        const identity = resolved.routeKey
+          ? `${resolved.routeKey}\u0000${resolved.workspaceGeneration}`
+          : ftAgentId;
+        const key = `${client.userId}:${identity}`;
         userFileTabs.set(key, {
           files: (msg.openFiles || []).map(f => ({ path: f.path })),
-          activeIndex: msg.activeIndex || 0,
+          activeIndex: Number.isFinite(msg.activeIndex) ? msg.activeIndex : 0,
           timestamp: Date.now()
         });
       }
@@ -88,10 +96,19 @@ export async function handleClientMisc(clientId, client, msg, checkAgentAccess)
       const ftAgentId = msg.agentId || client.currentAgent;
       if (client.userId && ftAgentId) {
         if (!await checkAgentAccess(ftAgentId)) break;
-        const key = `${client.userId}:${ftAgentId}`;
+        const resolved = resolveWorkbenchRequest(client, msg, ftAgentId);
+        if (!resolved) break;
+        const identity = resolved.routeKey
+          ? `${resolved.routeKey}\u0000${resolved.workspaceGeneration}`
+          : ftAgentId;
+        const key = `${client.userId}:${identity}`;
         const saved = userFileTabs.get(key);
         await sendToWebClient(client, {
           type: 'file_tabs_restored',
+          agentId: ftAgentId,
+          conversationId: resolved.conversationId || msg.conversationId || client.currentConversation,
+          workbenchRouteKey: resolved.routeKey,
+          workbenchWorkspaceGeneration: resolved.workspaceGeneration,
           openFiles: saved?.files || [],
           activeIndex: saved?.activeIndex || 0
         });