@jingyi0605/codingns4dsh 0.2.0-beta.2 → 0.2.0-rc3

package/data/build/dist/client/terminal/model.js

@@ -1,5 +1,7 @@
 import { Service } from '@deepseek-ai/cordis';
 import { debugInfo, debugWarn } from '../../shared/debug.js';
+import { resolveCodingNsTranslator } from '../locale.js';
+import { stripTerminalDeviceAttributeResponses } from '../../shared/terminal-input.js';
 class ObservableValue {
     value;
     listeners = new Set();
@@ -17,16 +19,17 @@ class ObservableValue {
             listener();
     }
 }
-/** 一个 Sidebar 标签对应的终端模型；DOM 卸载只 detach，显式 close 才结束 Host 进程。 */
+/** 一个 Sidebar 标签对应的终端模型；普通视图卸载只 detach，聚合视图可常驻 follow。 */
 export class CodingNsTerminalView {
     sessionId;
     remote;
     createWhenMissing;
     shellPath;
     onWorkspaceResolved;
+    t;
     state;
     id;
-    store = new ObservableValue({ phase: 'idle', title: '终端', writable: false });
+    store;
     lifetime = new AbortController();
     followController;
     pendingRender;
@@ -37,26 +40,65 @@ export class CodingNsTerminalView {
     attachmentId;
     /** 最近一次已排队的尺寸；ResizeObserver 可能在同一布局周期内重复触发。 */
     lastResize;
-    constructor(sessionId, id, remote, createWhenMissing, shellPath, onWorkspaceResolved) {
+    reconnectTimer;
+    reconnectAttempts = 0;
+    /**
+     * 聚合终端由工作区库存拥有生命周期。
+     *
+     * 聚合页在切换右栏页签时可能会卸载 DOM，但 Host 里的终端仍然运行；
+     * 这类视图不能因为一次 DOM 卸载就释放 follow，否则再次点开标签必然
+    * 重新经历 environment/list/follow。显式 close 和 dispose 仍会强制释放。
+    */
+    keepAlive;
+    initialState;
+    initialStateConsumed = false;
+    constructor(sessionId, id, remote, createWhenMissing, shellPath, onWorkspaceResolved, 
+    // 追加在末尾：既有调用方与测试按位置传 shellPath / onWorkspaceResolved，不能前移。
+    t = resolveCodingNsTranslator(), keepAlive = false, initialState) {
         this.sessionId = sessionId;
         this.remote = remote;
         this.createWhenMissing = createWhenMissing;
         this.shellPath = shellPath;
         this.onWorkspaceResolved = onWorkspaceResolved;
+        this.t = t;
         this.id = id;
+        this.keepAlive = keepAlive;
+        this.initialState = initialState;
+        // 标签兜底标题必须走词典：字段初始化阶段还取不到构造参数，因此在构造函数里建 store。
+        this.store = new ObservableValue({
+            phase: initialState?.info === undefined ? 'idle' : 'disconnected',
+            ...(initialState?.environment === undefined ? {} : { environment: initialState.environment }),
+            ...(initialState?.info === undefined ? {} : { info: initialState.info }),
+            title: initialState?.info?.title ?? t('terminal.title'),
+            writable: false,
+        });
         this.state = this.store;
     }
     mount() {
         this.mounted += 1;
-        if (this.mounted === 1)
-            void this.refresh();
+        if (this.mounted === 1) {
+            const initial = this.initialState;
+            if (!this.initialStateConsumed && initial?.info !== undefined) {
+                this.initialStateConsumed = true;
+                // 库存快照已经证明终端仍在运行时，直接订阅 Host 常驻连接，
+                // 不再为切换会话重新读取 environment/list。环境快照尚未到达时也
+                // 可以 follow：environment 只影响输入上限和外观默认值，不能阻塞恢复。
+                if (initial.info.state === 'running')
+                    this.connect();
+                else
+                    void this.refresh();
+            }
+            else {
+                void this.refresh();
+            }
+        }
         let active = true;
         return () => {
             if (!active)
                 return;
             active = false;
             this.mounted = Math.max(0, this.mounted - 1);
-            if (this.mounted === 0)
+            if (this.mounted === 0 && !this.keepAlive)
                 this.detach();
         };
     }
@@ -68,6 +110,44 @@ export class CodingNsTerminalView {
         this.loading = this.load().finally(() => { this.loading = undefined; });
         return this.loading;
     }
+    /**
+     * 运行时丢失后按当前绑定重建终端。
+     *
+     * 这是"进程已经不存在"时的显式恢复动作：沿用同一个 terminalId 与工作区绑定，
+     * 让 Sidebar 标签、标题和尺寸都保持不变，而不是让用户去点"新建终端"。
+     */
+    async rebuild() {
+        if (this.loading !== undefined)
+            return this.loading;
+        this.clearReconnect();
+        this.reconnectAttempts = 0;
+        this.patch({ phase: 'loading', writable: false });
+        const task = this.loadWithRebuild().finally(() => { this.loading = undefined; });
+        this.loading = task;
+        return task;
+    }
+    async loadWithRebuild() {
+        try {
+            const remote = resolveRemote(this.remote);
+            const environment = unwrap(await remote.environment(this.sessionId, this.lifetime.signal));
+            this.patch({ phase: 'creating', environment });
+            const info = unwrap(await remote.create(this.sessionId, {
+                id: this.id,
+                ...(this.shellPath === undefined ? {} : { shellPath: this.shellPath }),
+                cols: Math.min(80, environment.maxCols),
+                rows: Math.min(24, environment.maxRows),
+            }, this.lifetime.signal));
+            debugInfo('codingns4dsh: client terminal rebuilt', { sessionId: this.sessionId, terminalId: info.id });
+            const { error: _error, ...rest } = this.store.getSnapshot();
+            this.store.set({ ...rest, environment, info, title: info.title });
+            if (this.mounted > 0)
+                this.connect();
+        }
+        catch (error) {
+            if (!this.lifetime.signal.aborted)
+                this.fail(error);
+        }
+    }
     acknowledge(revision) {
         if (this.pendingRender?.revision !== revision)
             return;
@@ -75,6 +155,9 @@ export class CodingNsTerminalView {
         this.pendingRender = undefined;
     }
     write(data) {
+        data = stripTerminalDeviceAttributeResponses(data);
+        if (data === '')
+            return;
         const state = this.store.getSnapshot();
         const attachmentId = this.attachmentId;
         if (!state.writable || attachmentId === undefined || data === '')
@@ -149,7 +232,10 @@ export class CodingNsTerminalView {
                     if (binding.id !== this.id)
                         this.id = binding.id;
                     // 工作区已有绑定时，恢复必须失败闭合，不能用新 ID 偷建替代终端。
-                    createWhenMissing = !binding.existing;
+                    // 显式传入 terminalId 或读取到会话绑定时同样不能新建：工作区绑定
+                    // 可能刚被另一个会话的关闭动作删除，此时旧标签仍在卸载途中，不能
+                    // 把已经关闭的 ID 当成新终端重新 create。
+                    createWhenMissing = createWhenMissing && !binding.existing;
                 }
             }
             const listed = unwrap(await remote.list(this.sessionId));
@@ -179,6 +265,7 @@ export class CodingNsTerminalView {
     connect() {
         if (this.followController !== undefined || this.lifetime.signal.aborted || this.mounted === 0)
             return;
+        this.clearReconnect();
         const controller = new AbortController();
         this.followController = controller;
         this.attachmentId = crypto.randomUUID();
@@ -200,12 +287,22 @@ export class CodingNsTerminalView {
                 }
                 await this.deliver(frame);
             }
-            if (!signal.aborted)
-                this.patch({ phase: 'disconnected', writable: false });
+            if (!signal.aborted) {
+                // 流正常结束但终端仍在运行：这是连接层断开（Host 重连、服务器短暂不可达），
+                // 必须自动重连；只有真正结束的终端才停在终态。
+                if (this.isRunning())
+                    this.scheduleReconnect();
+                else
+                    this.patch({ phase: 'disconnected', writable: false });
+            }
         }
         catch (error) {
-            if (!signal.aborted)
-                this.fail(error);
+            if (!signal.aborted) {
+                if (this.isRunning())
+                    this.scheduleReconnect();
+                else
+                    this.fail(error);
+            }
         }
         finally {
             if (this.followController?.signal === signal) {
@@ -215,6 +312,9 @@ export class CodingNsTerminalView {
         }
     }
     async deliver(frame) {
+        // 真正收到画面才算连接成功，退避计数在这里归零。
+        this.reconnectAttempts = 0;
+        this.clearReconnect();
         this.pendingRender?.resolve();
         this.revision += 1;
         let resolveWaiting = () => { };
@@ -224,6 +324,7 @@ export class CodingNsTerminalView {
         await waiting;
     }
     detach() {
+        this.clearReconnect();
         this.pendingRender?.resolve();
         this.pendingRender = undefined;
         this.followController?.abort(new Error('终端视图已 detach'));
@@ -235,6 +336,54 @@ export class CodingNsTerminalView {
             this.store.set({ ...state, phase: 'disconnected', writable: false });
         }
     }
+    /** 终端是否仍被认为在运行；终态（exited/failed/closed）不参与自动重连。 */
+    isRunning() {
+        const state = this.store.getSnapshot();
+        if (state.phase === 'closed' || state.phase === 'failed')
+            return false;
+        if (state.info === undefined)
+            return true;
+        return state.info.state === 'running';
+    }
+    /**
+     * 恢复阶段 Host 列表为空时，判断当前标签是否仍有本地生命周期保护。
+     * 新建终端在 create 完成前不能被恢复流程关闭；已连接且 Host 报告 running
+     * 的终端也不能因为一次空列表响应被误判为残留。
+     */
+    isRecoveryProtected() {
+        const state = this.store.getSnapshot();
+        if (state.phase === 'closed' || state.phase === 'failed')
+            return false;
+        if (this.createWhenMissing && (state.phase === 'idle' || state.phase === 'loading' || state.phase === 'creating'))
+            return true;
+        return state.info?.id === this.id && state.info.state === 'running';
+    }
+    /**
+     * 连接层断开后的自动重连。
+     *
+     * 指数退避到 5 秒封顶：DSH 重启、中继抖动或 tmux 服务器短暂不可达时，用户
+     * 不需要手动点"重新连接"，也不会看到刷屏式的重试。
+     */
+    scheduleReconnect() {
+        if (this.reconnectTimer !== undefined || this.lifetime.signal.aborted || this.mounted === 0)
+            return;
+        const delay = Math.min(500 * 2 ** this.reconnectAttempts, 5000);
+        this.reconnectAttempts += 1;
+        this.patch({ phase: 'disconnected', writable: false });
+        debugInfo('codingns4dsh: client terminal reconnect scheduled', { sessionId: this.sessionId, terminalId: this.id, delay, attempt: this.reconnectAttempts });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            if (this.lifetime.signal.aborted || this.mounted === 0)
+                return;
+            void this.refresh();
+        }, delay);
+    }
+    clearReconnect() {
+        if (this.reconnectTimer !== undefined) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+    }
     patch(patch) {
         this.store.set({ ...this.store.getSnapshot(), ...patch });
     }
@@ -248,6 +397,7 @@ const SHELL_KEY = 'dsh.codingns.terminal.shell.v1';
 /** Codingns4DSH 自有的浏览器终端服务，不依赖官方 terminal-controller Client 实现。 */
 export class CodingNsWebTerminals extends Service {
     remote;
+    t;
     views = new Map();
     workspaceIds = new Map();
     recoveries = new Map();
@@ -255,38 +405,87 @@ export class CodingNsWebTerminals extends Service {
     closeFailures = this.closeFailureStore;
     remoteReadyStore = new ObservableValue(false);
     remoteReadyState = this.remoteReadyStore;
+    inventoryRevisionStore = new ObservableValue(0);
+    /** 任一工作区库存变化都会递增；聚合页用它触发跨会话刷新。 */
+    inventoryRevision = this.inventoryRevisionStore;
+    inventories = new Map();
+    /** 已解析过的会话环境；切换回已有会话时无需再次请求 Host environment。 */
+    environments = new Map();
+    /** 每个会话最近一次库存请求的序号；旧请求返回时不得覆盖新建结果。 */
+    inventoryRequestIds = new Map();
+    /** 任意工作区刷新都会递增；尚未解析工作区的旧请求也必须随之失效。 */
+    inventoryEpoch = 0;
     closeRequests = new Map();
     /** Remote 注入前不能执行关闭请求；就绪后统一冲刷，避免把启动竞态显示成永久错误。 */
     cleanupQueued = false;
-    constructor(ctx, remote) {
+    constructor(ctx, remote, t = resolveCodingNsTranslator()) {
         super(ctx, 'webTerminals');
         this.remote = remote;
+        this.t = t;
         for (const request of readCloseRequests())
             this.closeRequests.set(String(request.id), request);
         void this.flushCleanup();
     }
-    view(sessionId, key, contentId, terminalId, shellPath) {
+    view(sessionId, key, contentId, terminalId, shellPath, createFresh = false, persistBinding = true, keepAlive = false, initialState) {
         const mapKey = JSON.stringify([sessionId, key]);
         const existing = this.views.get(mapKey);
         if (existing !== undefined)
             return existing.view;
         const workspaceId = this.workspaceIds.get(sessionId);
-        const saved = terminalId
-            ?? (workspaceId === undefined ? undefined : readWorkspaceBindingWithMigration(workspaceId, contentId))
-            ?? readBinding(sessionId, contentId);
+        const sessionBinding = readBinding(sessionId, contentId);
+        // “新建”是一次性动作：首次消费标记时忽略工作区单终端绑定，生成新的身份；
+        // 标签重载后若已有会话绑定，则恢复刚创建的终端，避免再次创建重复进程。
+        const fresh = createFresh && sessionBinding === undefined;
+        const saved = fresh
+            ? terminalId
+            : terminalId
+                ?? sessionBinding
+                ?? (workspaceId === undefined ? undefined : readWorkspaceBindingWithMigration(workspaceId, contentId));
         const id = saved ?? crypto.randomUUID();
         debugInfo('codingns4dsh: client terminal view', { sessionId, key, contentId, workspaceId: workspaceId ?? null, savedId: saved ?? null, terminalId: id, bindingSource: terminalId !== undefined ? 'argument' : workspaceId !== undefined && readWorkspaceBindingWithMigration(workspaceId, contentId) !== undefined ? 'workspace-storage' : readBinding(sessionId, contentId) !== undefined ? 'session-storage' : 'new' });
-        if (saved === undefined)
+        if (persistBinding && (fresh || saved === undefined))
             writeBinding(sessionId, contentId, id);
-        const view = new CodingNsTerminalView(sessionId, id, this.remote, saved === undefined, shellPath, (resolvedWorkspaceId, currentId) => this.rememberWorkspace(sessionId, contentId, currentId, resolvedWorkspaceId));
+        const view = new CodingNsTerminalView(sessionId, id, this.remote, fresh || saved === undefined, shellPath, persistBinding
+            ? (resolvedWorkspaceId, currentId) => this.rememberWorkspace(sessionId, contentId, currentId, resolvedWorkspaceId, !fresh && terminalId === undefined)
+            : (resolvedWorkspaceId) => { this.workspaceIds.set(sessionId, resolvedWorkspaceId); return undefined; }, this.t, keepAlive, initialState);
         this.views.set(mapKey, { contentId, view });
         return view;
     }
+    /** 聚合页按 Host terminalId 获取内部视图，不再依赖 Sidebar 标签身份。 */
+    viewForTerminal(sessionId, terminalId, shellPath) {
+        const key = `aggregate:${terminalId}`;
+        const info = this.inventoryForSession(sessionId).find((item) => item.id === terminalId);
+        const environment = this.environmentForSession(sessionId);
+        const initialState = info === undefined && environment === undefined
+            ? undefined
+            : {
+                ...(info === undefined ? {} : { info }),
+                ...(environment === undefined ? {} : { environment }),
+            };
+        return this.view(sessionId, key, key, terminalId, shellPath, false, false, true, initialState);
+    }
     /** 返回某个 Sidebar 内容已经保存的 Host 终端身份，用于恢复时去重。 */
     boundTerminalId(sessionId, contentId) {
         const workspaceId = this.workspaceIds.get(sessionId);
-        return (workspaceId === undefined ? undefined : readWorkspaceBindingWithMigration(workspaceId, contentId))
-            ?? readBinding(sessionId, contentId);
+        return readBinding(sessionId, contentId)
+            ?? (workspaceId === undefined ? undefined : readWorkspaceBindingWithMigration(workspaceId, contentId));
+    }
+    /**
+     * 判断恢复阶段是否应保留某个标签。
+     *
+     * Host 列表为空有两种含义：新建终端的 create 还没有完成，或者 Host 已经
+     * 关闭终端而 Sidebar 只剩残留标签。只有当前 Client 视图明确处于创建中或
+     * 仍收到 Host 的 running 状态时，空列表才属于前一种情况。
+     */
+    isTerminalRecoveryProtected(sessionId, contentId, terminalId) {
+        for (const record of this.views.values()) {
+            if (record.view.sessionId !== sessionId || record.contentId !== contentId)
+                continue;
+            if (record.view.id !== terminalId)
+                continue;
+            return record.view.isRecoveryProtected();
+        }
+        return false;
     }
     async launchShells(sessionId, signal) {
         const shells = unwrap(await resolveRemote(this.remote).shells(sessionId, signal));
@@ -297,6 +496,32 @@ export class CodingNsWebTerminals extends Service {
         };
     }
     selectShell(path) { writeString(SHELL_KEY, path); }
+    /** 在聚合页内创建一个新的 Host 终端，并把它加入工作区库存。 */
+    async createTerminal(sessionId, shellPath) {
+        const terminalId = crypto.randomUUID();
+        const view = this.view(sessionId, `aggregate:${terminalId}`, `aggregate:${terminalId}`, terminalId, shellPath, true, false, true);
+        await view.refresh();
+        const info = view.state.getSnapshot().info;
+        if (info === undefined)
+            throw new Error(view.state.getSnapshot().error ?? '终端创建失败');
+        await this.refreshInventory(sessionId);
+        return info;
+    }
+    /** 只关闭指定 terminalId；其他会话中对应的 attach 视图只做 detach。 */
+    async closeTerminal(sessionId, terminalId) {
+        const records = [...this.views.entries()].filter(([, record]) => record.view.id === terminalId);
+        const primary = records.find(([, record]) => record.view.sessionId === sessionId)?.[1];
+        if (primary !== undefined)
+            await primary.view.close();
+        else
+            unwrap(await resolveRemote(this.remote).close(sessionId, terminalId));
+        for (const [mapKey, record] of records) {
+            this.views.delete(mapKey);
+            // close() 只结束 Host 终端，dispose() 负责释放聚合视图保留的 follow。
+            await record.view.dispose();
+        }
+        await this.refreshInventory(sessionId);
+    }
     close(sessionId, key, contentId, terminalId) {
         const mapKey = JSON.stringify([sessionId, key]);
         const record = this.views.get(mapKey);
@@ -304,13 +529,13 @@ export class CodingNsWebTerminals extends Service {
         if (id === undefined)
             return;
         debugInfo('codingns4dsh: client terminal close request', { sessionId, key, contentId, workspaceId: this.workspaceIds.get(sessionId) ?? null, terminalId: id, hasView: record !== undefined });
-        const request = { sessionId, id, title: record?.view.state.getSnapshot().title ?? '终端' };
+        const request = { sessionId, id, title: record?.view.state.getSnapshot().title ?? this.t('terminal.title') };
         this.closeRequests.set(String(id), request);
         persistCloseRequests(this.closeRequests.values());
         deleteBinding(sessionId, contentId);
         const workspaceId = this.workspaceIds.get(sessionId);
         if (workspaceId !== undefined) {
-            deleteWorkspaceBinding(workspaceId);
+            deleteWorkspaceBindingIfMatches(workspaceId, id);
             deleteLegacyWorkspaceBinding(workspaceId, contentId);
         }
         this.views.delete(mapKey);
@@ -320,15 +545,44 @@ export class CodingNsWebTerminals extends Service {
         const pending = this.recoveries.get(sessionId);
         if (pending !== undefined)
             return pending;
+        const requestId = (this.inventoryRequestIds.get(sessionId) ?? 0) + 1;
+        this.inventoryRequestIds.set(sessionId, requestId);
+        const inventoryEpoch = this.inventoryEpoch;
         // 官方 list wire 只有 sessionId；先用 agent-scoped environment 让 Host 解析工作区。
-        const recovery = (async () => {
-            const environment = unwrap(await resolveRemote(this.remote).environment(sessionId));
+        // 使用可选变量避免 TS 将闭包中的自引用判定为“赋值前使用”；
+        // Promise 创建后才会执行异步主体，因此运行时仍能安全比较身份。
+        let recovery;
+        recovery = (async () => {
+            const environment = await this.resolveEnvironment(sessionId);
             if (environment.workspaceId !== undefined)
                 this.workspaceIds.set(sessionId, environment.workspaceId);
-            const result = unwrap(await resolveRemote(this.remote).list(sessionId));
+            const result = dedupeInventory(unwrap(await resolveRemote(this.remote).list(sessionId)));
+            const currentRequestId = this.inventoryRequestIds.get(sessionId);
+            if (currentRequestId !== requestId || this.inventoryEpoch !== inventoryEpoch) {
+                // 工作区尚未解析时，刷新方无法提前把这个会话加入失效集合。
+                // 旧 list 结果不能交给 Sidebar，否则关闭后的终端会被重新投影出来；
+                // 让当前会话重新发起一轮查询，直到拿到刷新后的库存。
+                debugInfo('codingns4dsh: client terminal recover stale retry', {
+                    sessionId,
+                    terminalIds: result.map((entry) => entry.id),
+                    requestId,
+                    currentRequestId,
+                    inventoryEpoch,
+                    currentInventoryEpoch: this.inventoryEpoch,
+                });
+                // 当前请求尚未进入 finally；先移除自身，才能让 retry 创建新一代
+                // Promise，而不是再次命中这个仍在执行的旧请求。
+                if (recovery !== undefined && this.recoveries.get(sessionId) === recovery)
+                    this.recoveries.delete(sessionId);
+                return this.recover(sessionId);
+            }
             debugInfo('codingns4dsh: client terminal recover', { sessionId, workspaceId: environment.workspaceId, terminalIds: result.map((entry) => entry.id) });
+            this.rememberInventory(sessionId, result);
             return result;
-        })().finally(() => this.recoveries.delete(sessionId));
+        })().finally(() => {
+            if (recovery !== undefined && this.recoveries.get(sessionId) === recovery)
+                this.recoveries.delete(sessionId);
+        });
         this.recoveries.set(sessionId, recovery);
         return recovery;
     }
@@ -348,18 +602,80 @@ export class CodingNsWebTerminals extends Service {
         this.views.clear();
         this.workspaceIds.clear();
         this.recoveries.clear();
+        this.inventories.clear();
+        this.environments.clear();
+        this.inventoryRequestIds.clear();
+        this.inventoryEpoch = 0;
+    }
+    /** 强制刷新当前会话对应工作区的库存。 */
+    async refreshInventory(sessionId) {
+        this.inventoryEpoch += 1;
+        // 聚合页创建/关闭后必须绕过同一工作区所有会话的旧 list 请求；否则
+        // 另一个会话的迟到响应仍可能把关闭后的终端写回共享库存。
+        const workspaceId = this.workspaceIds.get(sessionId);
+        const invalidated = new Set();
+        for (const [knownSessionId, knownWorkspaceId] of this.workspaceIds) {
+            if (knownSessionId === sessionId || (workspaceId !== undefined && knownWorkspaceId === workspaceId)) {
+                invalidated.add(knownSessionId);
+            }
+        }
+        invalidated.add(sessionId);
+        for (const knownSessionId of invalidated)
+            this.invalidateRecovery(knownSessionId);
+        return this.recover(sessionId);
+    }
+    /** 令指定会话尚未完成的库存请求失效，并清掉可复用的旧 Promise。 */
+    invalidateRecovery(sessionId) {
+        this.inventoryRequestIds.set(sessionId, (this.inventoryRequestIds.get(sessionId) ?? 0) + 1);
+        this.recoveries.delete(sessionId);
+    }
+    async resolveEnvironment(sessionId) {
+        const cached = this.environments.get(`session:${sessionId}`);
+        if (cached !== undefined)
+            return cached;
+        const environment = unwrap(await resolveRemote(this.remote).environment(sessionId));
+        this.environments.set(`session:${sessionId}`, environment);
+        if (environment.workspaceId !== undefined)
+            this.environments.set(`workspace:${environment.workspaceId}`, environment);
+        return environment;
+    }
+    environmentForSession(sessionId) {
+        const session = this.environments.get(`session:${sessionId}`);
+        if (session !== undefined)
+            return session;
+        const workspaceId = this.workspaceIds.get(sessionId);
+        return workspaceId === undefined ? undefined : this.environments.get(`workspace:${workspaceId}`);
+    }
+    /** 返回当前会话最近一次拿到的工作区库存；首次加载时为空。 */
+    inventoryForSession(sessionId) {
+        const workspaceId = this.workspaceIds.get(sessionId) ?? `session:${sessionId}`;
+        return this.inventories.get(workspaceId)?.terminals ?? [];
     }
-    rememberWorkspace(sessionId, contentId, id, workspaceId) {
+    rememberWorkspace(sessionId, contentId, id, workspaceId, useWorkspaceBinding) {
         this.workspaceIds.set(sessionId, workspaceId);
-        const existing = readWorkspaceBindingWithMigration(workspaceId, contentId);
+        // 显式恢复和“新建”都必须保留自己的 terminalId；只有普通无参数入口
+        // 才使用旧的单终端工作区绑定兼容行为。
+        const existing = useWorkspaceBinding ? readWorkspaceBindingWithMigration(workspaceId, contentId) : undefined;
         const resolvedId = existing ?? id;
         // 修正首次渲染时已经写入的会话键，避免第二个会话继续携带临时 ID。
         writeBinding(sessionId, contentId, resolvedId);
-        // 旧版本的工作区键带 contentId；统一重写成只含 Workspace ID 的新键。
-        writeWorkspaceBinding(workspaceId, contentId, resolvedId);
-        deleteLegacyWorkspaceBinding(workspaceId, contentId);
+        if (useWorkspaceBinding) {
+            // 旧版本的工作区键带 contentId；统一重写成只含 Workspace ID 的新键。
+            writeWorkspaceBinding(workspaceId, contentId, resolvedId);
+            deleteLegacyWorkspaceBinding(workspaceId, contentId);
+        }
         return { id: resolvedId, existing: existing !== undefined };
     }
+    rememberInventory(sessionId, terminals) {
+        const workspaceId = this.workspaceIds.get(sessionId) ?? `session:${sessionId}`;
+        const normalized = dedupeInventory(terminals);
+        const previous = this.inventories.get(workspaceId);
+        if (previous !== undefined && sameInventory(previous.terminals, normalized))
+            return;
+        const revision = this.inventoryRevisionStore.getSnapshot() + 1;
+        this.inventories.set(workspaceId, { workspaceId, terminals: normalized, revision });
+        this.inventoryRevisionStore.set(revision);
+    }
     async cleanup(request, view) {
         try {
             debugInfo('codingns4dsh: client terminal cleanup begin', { sessionId: request.sessionId, terminalId: request.id, hasView: view !== undefined });
@@ -371,6 +687,15 @@ export class CodingNsWebTerminals extends Service {
             this.closeRequests.delete(String(request.id));
             persistCloseRequests(this.closeRequests.values());
             this.closeFailureStore.set(this.closeFailureStore.getSnapshot().filter((item) => item.id !== request.id));
+            // 兼容旧 Sidebar 的显式关闭路径：关闭成功后也必须刷新工作区库存，
+            // 否则其他会话会继续看到已经关闭的终端记录。
+            void this.refreshInventory(request.sessionId).catch((error) => {
+                debugWarn('codingns4dsh: client terminal inventory refresh after close failed', {
+                    sessionId: request.sessionId,
+                    terminalId: request.id,
+                    error: errorMessage(error),
+                });
+            });
         }
         catch (error) {
             if (isTerminalRemoteUnavailable(error)) {
@@ -413,10 +738,21 @@ function unwrap(result) {
         return result.value;
     throw result.error;
 }
+/**
+ * 终端 Remote 尚未注入时的稳定错误。
+ *
+ * 调用方按类型判断可用性，不能比较本地化后的 message 文本。
+ */
+export class TerminalRemoteUnavailableError extends Error {
+    constructor() {
+        super('终端服务尚未就绪，请稍后重试');
+        this.name = 'TerminalRemoteUnavailableError';
+    }
+}
 function resolveRemote(source) {
     const remote = typeof source === 'function' ? source() : source;
     if (remote === undefined)
-        throw new Error('终端服务尚未就绪，请稍后重试');
+        throw new TerminalRemoteUnavailableError();
     return remote;
 }
 function sameResize(left, right) {
@@ -426,7 +762,25 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function isTerminalRemoteUnavailable(error) {
-    return errorMessage(error) === '终端服务尚未就绪，请稍后重试';
+    return error instanceof TerminalRemoteUnavailableError;
+}
+function sameInventory(left, right) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length; index += 1) {
+        const a = left[index];
+        const b = right[index];
+        if (a.id !== b.id || a.title !== b.title || a.cwd !== b.cwd || a.cols !== b.cols || a.rows !== b.rows || a.state !== b.state || a.exitCode !== b.exitCode || a.shell.path !== b.shell.path || a.shell.name !== b.shell.name)
+            return false;
+    }
+    return true;
+}
+/** Host 列表按 terminalId 去重，避免重复记录共享同一个关闭动作。 */
+function dedupeInventory(terminals) {
+    const unique = new Map();
+    for (const terminal of terminals)
+        unique.set(terminal.id, terminal);
+    return [...unique.values()];
 }
 function bindingKey(sessionId, contentId) {
     return `${BINDING_PREFIX}${JSON.stringify([sessionId, contentId])}`;
@@ -467,6 +821,11 @@ function deleteWorkspaceBinding(workspaceId, _contentId) {
     }
     catch { /* 浏览器禁用存储时仅失去跨刷新绑定。 */ }
 }
+function deleteWorkspaceBindingIfMatches(workspaceId, id) {
+    if (readWorkspaceBinding(workspaceId) !== id)
+        return;
+    deleteWorkspaceBinding(workspaceId);
+}
 function deleteLegacyWorkspaceBinding(workspaceId, contentId) {
     try {
         localStorage.removeItem(legacyWorkspaceBindingKey(workspaceId, contentId));