@ai-workbench/remote-agent 0.8.23 → 0.8.25

package/README.md

@@ -1,12 +1,14 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.23 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.25 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
-文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，不自动迁移旧会话的来源。
+文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，已有主机会话只提取一次原有主机来源并保存。
+
+需要远程主机连接组件 0.7.29 或更新的 0.7.x，以及联网助手 0.4.9。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
 
 ## 会话行为
 
-每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。改变文件来源后请新建会话。
+每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。
 
 断线会结束本轮；操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止下一轮。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
 
@@ -17,7 +19,7 @@ DSH 启动和打开模型菜单时读取一次主机型号列表。发送时不
 - 员工选本机文件夹，就在员工电脑上执行；通道失败不会改在主机运行。
 - 订阅凭据留在主机，不放进命令参数、日志或技术详情。
 - 跟随 DSH 当前权限：完全权限不问、工作区内修改先问、仅可查看只读。需要审批时使用官方卡片。
-- 一条会话对应一个工作区来源；换来源请新建会话。
+- 一条会话对应一个文件来源；主机来源不会随工作区后续选择改变，本机来源继续沿用原生绑定。
 
 Codex 员工端只使用随包提供的原生组件，通道等待本次组件的启动标记后才完成开通，不逐通道执行摘要或版本校验。当前员工端支持范围以发布验证记录为准，不让员工手填执行器路径。
 
@@ -40,6 +42,8 @@ Codex 员工端只使用随包提供的原生组件，通道等待本次组件
 
 技术详情只写官方 profile 下本地私有日志，并由既有技术详情界面展开显示。写入失败不覆盖原始错误、不等待远端投递回执。每个运行环境只记录首次关闭原因；首先观察到的原因不自动等同跨层根因。
 
-工程验证、独立审查、固定包摘要及实际设备验收分别记录在 `docs/evidence/2026-10-24-X-executor-readiness/` 和项目 X 回执中。插件不修改 DSH 核心，不添加启动器或自定义 profile。
+工程验证和独立审查见 `docs/evidence/2026-10-25-X-host-source-v2/`；AUTH profile 夹具补齐与最终 main 全套复验见其中的 `auth-profile-return.md`。固定包摘要及真实设备验收状态以项目 X 回执为准。插件不修改 DSH 核心，不添加启动器或自定义 profile。
 
 远程助手参数页只显示官方 ConfigForms 当前值，不提供保存、放弃或恢复继承值；修改请使用 DSH 官方 Config“打开配置文件”入口。
+
+模型目录在官方启动读取时获取，并在连接变为 connected 时经官方注册刷新；官方菜单打开或重试读取缓存是 DSH 官方限制，本插件不改官方菜单或核心。真正不支持的推理档位由 DSH 预检，其英文提示保留为观察项。

package/dist/acp.js

@@ -484,7 +484,7 @@ export class AcpSession {
         signal?.addEventListener('abort', abort, { once: true });
         try {
             const hello = await this.stage('acp-initialize', () => this.connection.agent.request(acp.methods.agent.initialize, {
-                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.23' },
+                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.24' },
                 clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false, session: { notices: {} }, ...(this.employeeMeta ? { _meta: { awEmployeeExecution: { version: 1, closeReason: 1 } } } : {}) },
             }, { cancellationSignal: signal }));
             if (hello.protocolVersion !== acp.PROTOCOL_VERSION)

package/dist/connect-contract.d.ts

@@ -20,5 +20,5 @@ export type SessionProjectResolution = HostSessionProjectTarget;
 export interface NativeWorkspaceApi {
     getContractInfo(): ContractInfo;
     ensureReady(provider: LoginProvider): Promise<ConnectResult<ConnectTarget>>;
-    resolveSessionProject(sessionId: string, use: WorkspaceUse, location?: HostWorkspaceResolveContext): Promise<ConnectResult<SessionProjectResolution>>;
+    resolveSessionProject(sessionId: string, use: WorkspaceUse, location: HostWorkspaceResolveContext): Promise<ConnectResult<SessionProjectResolution>>;
 }

package/dist/employee-mcp.js

@@ -152,7 +152,7 @@ export async function openEmployeeMcp(options) {
             return tools.call(request.params.name, request.params.arguments ?? {}, signal, event => { if (sink)
                 observeUsing(event, sink); });
         });
-        mcp.onerror = () => { observeConnection?.({ layer: 'relay', initiator: 'mcp.server-error', reason: 'EMPLOYEE_MCP_PROTOCOL_OR_TRANSPORT_ERROR', action: 'failure' }); observe({ kind: 'session', severity: 'warning', code: 'CLAUDE_EMPLOYEE_MCP_UNKNOWN', summary: '本机工具连接出现协议或传输错误；恢复后可在原会话继续。' }); };
+        mcp.onerror = () => { observeConnection?.({ layer: 'relay', initiator: 'mcp.server-error', reason: 'EMPLOYEE_MCP_PROTOCOL_OR_TRANSPORT_ERROR', action: 'failure' }); observe({ kind: 'session', severity: 'warning', code: 'CLAUDE_EMPLOYEE_MCP_UNKNOWN', summary: '本机工具连接中断，在途结果未知，没有重放；恢复后可在原会话继续。' }); };
         mcp.onclose = () => { observeConnection?.({ layer: 'relay', initiator: 'mcp.client-closed', reason: 'MCP_CLIENT_CLOSED', action: 'close' }); clients.delete(mcp); transports.delete(transport); };
         void mcp.connect(transport).catch(error => { observeConnection?.({ layer: 'relay', initiator: 'mcp.connect-failure', reason: closeCode(error, 'MCP_CONNECT_FAILED'), action: 'close' }); socket.destroy(); });
     });

package/dist/host-workspace.d.ts

@@ -1,15 +1,10 @@
-import type { ConnectApi, ConnectTarget, ConnectionState, RuntimeRequest, Runtime } from './provider.ts';
-import type { NativeWorkspaceApi, HostSessionProjectTarget, LoginProvider } from './connect-contract.ts';
-export interface HostWorkspaceGuard {
-    readonly signal: AbortSignal;
-    readonly revocation: AbortSignal;
-    resolve(): Promise<HostSessionProjectTarget>;
-    assertCurrent(): void;
-    observeRuntime(runtime: Runtime): void;
-    dispose(): void;
-}
-/** Current official membership and explicit host selection; never infer source from a pathname. */
-export declare function hostWorkspaceGuard(get: () => ConnectApi | undefined, api: ConnectApi & NativeWorkspaceApi, connection: ConnectionState, target: ConnectTarget, request: RuntimeRequest, workspace: ((request: RuntimeRequest) => Promise<{
-    id: string;
-    path: string;
-}>) | undefined, provider: LoginProvider): Promise<HostWorkspaceGuard | undefined>;
+import type { HostWorkspaceResolveContext, LoginProvider, NativeWorkspaceApi } from './connect-contract.ts';
+import type { ConnectApi, RuntimeRequest } from './provider.ts';
+export type SessionSource = Readonly<HostWorkspaceResolveContext> | Readonly<{
+    source: 'local';
+}>;
+export declare const absoluteHostPath: (path: unknown) => path is string;
+/** Read only L's public source projection. Old host status/binding/physical fields have no meaning here. */
+export declare function workspaceSessionSource(api: ConnectApi, workspaceId: string, request?: RuntimeRequest): SessionSource | undefined;
+/** One L v2 resolution per user turn. L owns host/path checks and the current SSH target. */
+export declare function resolveHostWorkspace(api: ConnectApi & NativeWorkspaceApi, request: RuntimeRequest, provider: LoginProvider): Promise<import("@ai-workbench/connect/api").HostSessionProjectTarget>;

package/dist/host-workspace.js

@@ -1,114 +1,31 @@
-import { basename } from 'node:path/posix';
-import { awaitL, sameTarget, unwrap } from "./provider.js";
-import { connectNeedError } from "./connect-need.js";
+import { awaitL, unwrap } from "./provider.js";
 import { NeedError } from "./remote.js";
-const invalid = () => new NeedError('PROJECT_BINDING_INVALID', '文件来源已改，请新建会话继续；原会话历史仍可查看。', 'L核验的同一主机位置与目录身份');
-const hostIdentity = (v) => JSON.stringify(v ? [v.host, v.username, v.port] : null);
-const absolute = (v) => typeof v === 'string' && v.startsWith('/') && !v.includes('\0');
-function physical(d) {
-    if (!d || !absolute(d.requestedPath) || !absolute(d.path) || !(d.parentPath === null || absolute(d.parentPath)) || !d.identity || !d.entryIdentity || ![d.identity.device, d.identity.inode, d.entryIdentity.device, d.entryIdentity.inode].every(x => typeof x === 'string' && x.length > 0) || typeof d.isSymlink !== 'boolean' || !d.permissions || d.permissions.read !== true || d.permissions.execute !== true || !(typeof d.permissions.write === 'boolean' || d.permissions.write === null))
-        throw invalid();
-    // Directory contents change timestamps; neither timestamp is an execution identity.
-    return JSON.stringify([d.requestedPath, d.path, d.parentPath, d.identity.device, d.identity.inode, d.entryIdentity.device, d.entryIdentity.inode, d.isSymlink, d.permissions.read, d.permissions.write, d.permissions.execute]);
-}
-/** Current official membership and explicit host selection; never infer source from a pathname. */
-export async function hostWorkspaceGuard(get, api, connection, target, request, workspace, provider) {
-    if (api.getContractInfo().workspaceLocations !== 1 || typeof api.getWorkspaceLocationState !== 'function')
-        return;
-    const firstState = api.getWorkspaceLocationState();
-    if (!workspace) {
-        if (firstState.items.some(row => row.source === 'host'))
-            throw new NeedError('DEPENDENCY_REQUIRED', '我需要核对当前会话所属工作区，才能使用所选主机文件夹。', '官方会话与唯一workspaceRegistry关系');
+export const absoluteHostPath = (path) => typeof path === 'string' && path.startsWith('/') && !path.includes('\0');
+const unavailable = () => new NeedError('WORKSPACE_LOCATION_REQUIRED', '我需要这条会话原来选择的文件来源，请在远程主机连接中查看工作区文件来源。', '会话的主机名称和绝对目录');
+/** Read only L's public source projection. Old host status/binding/physical fields have no meaning here. */
+export function workspaceSessionSource(api, workspaceId, request) {
+    const rows = api.getWorkspaceLocationState?.().items.filter(row => row.workspaceId === workspaceId) ?? [];
+    if (rows.length !== 1)
         return;
+    const row = rows[0];
+    if (row.source === 'local') {
+        if (request?.cwd && request.cwd !== row.localPath)
+            throw unavailable();
+        return Object.freeze({ source: 'local' });
     }
-    const registered = { ...await workspace(request) };
-    request.signal?.throwIfAborted();
-    const state = api.getWorkspaceLocationState(), rows = state.items.filter(row => row.workspaceId === registered.id), selected = rows[0];
-    if (rows.length !== 1 || !selected)
+    if (row.source !== 'host')
         return;
-    if (selected.source !== 'host') {
-        if (selected.source !== null && selected.source !== 'local')
-            throw invalid();
-        return;
-    }
-    if (api.getContractInfo().hostWorkspaceResolution !== 1 || typeof api.onWorkspaceLocationState !== 'function' || typeof api.onConnectionState !== 'function')
-        throw new NeedError('DEPENDENCY_REQUIRED', '我需要支持主机位置解析的远程主机连接组件；本轮未执行，原话保留。', 'L >=0.7.20 / hostWorkspaceResolution:1');
-    if (state.instanceId !== connection.instanceId || state.epoch !== connection.epoch)
-        throw invalid();
-    if (state.need)
-        throw connectNeedError(state.need);
-    if (selected.need)
-        throw connectNeedError(selected.need);
-    if (!registered.id || !absolute(registered.path) || state.phase !== 'ready' || selected.status !== 'selected' || !selected.bindingId)
-        throw invalid();
-    const trusted = structuredClone(target);
-    if (selected.host && (selected.host.host !== trusted.host || selected.host.username !== trusted.username || selected.host.port !== trusted.port))
-        throw invalid();
-    const captured = structuredClone(selected), stamp = physical(captured.remote), context = { instanceId: connection.instanceId, epoch: connection.epoch, workspaceId: registered.id, expectedBindingId: selected.bindingId };
-    const revoked = new AbortController(), offs = [];
-    let runtime, disposed = false;
-    const current = () => {
-        request.signal?.throwIfAborted();
-        revoked.signal.throwIfAborted();
-        if (disposed || get() !== api || api.getContractInfo().hostWorkspaceResolution !== 1)
-            throw invalid();
-        const c = api.getConnectionState(), s = api.getWorkspaceLocationState(), items = s.items.filter(row => row.workspaceId === context.workspaceId), item = items[0];
-        if (c.phase !== 'connected' || c.instanceId !== context.instanceId || c.epoch !== context.epoch)
-            throw new NeedError('CONNECTION_LOST', '远程主机连接已变化，原派发已停止；请新建会话继续。', '本轮原连接代次');
-        if (s.instanceId !== context.instanceId || s.epoch !== context.epoch)
-            throw invalid();
-        if (s.need)
-            throw connectNeedError(s.need);
-        if (item?.need)
-            throw connectNeedError(item.need);
-        if (hostIdentity(item?.host) !== hostIdentity(captured.host))
-            throw invalid();
-        if (s.phase !== 'ready' || items.length !== 1 || item.bindingId !== context.expectedBindingId || item.workspaceId !== context.workspaceId || item.source !== 'host' || item.status !== 'selected' || item.localPath !== captured.localPath || physical(item.remote) !== stamp)
-            throw invalid();
-    };
-    const revoke = (error) => { if (revoked.signal.aborted)
-        return; runtime?.closeDiagnostics?.record({ layer: 'adapter', initiator: 'host-workspace.observer', reason: error instanceof NeedError ? error.code : 'HOST_WORKSPACE_REVOKED', action: 'abort', changes: [{ field: 'host-workspace.valid', before: true, after: false }] }); revoked.abort(error); };
-    const changed = () => { if (request.signal?.aborted && !revoked.signal.aborted)
-        return; try {
-        current();
-    }
-    catch (error) {
-        revoke(error);
-    } };
-    const dispose = () => { if (disposed)
-        return; disposed = true; for (const off of offs.splice(0))
-        off(); };
-    const membership = async () => { current(); const now = await workspace(request); current(); if (now.id !== registered.id || now.path !== registered.path)
-        throw invalid(); };
-    try {
-        current();
-        offs.push(api.onWorkspaceLocationState(changed));
-        offs.push(api.onConnectionState(changed));
-        current();
-        return { revocation: revoked.signal, signal: AbortSignal.any([revoked.signal, ...(request.signal ? [request.signal] : [])]), assertCurrent: current, observeRuntime(value) { runtime = value; current(); }, dispose,
-            async resolve() {
-                try {
-                    await membership();
-                    const value = unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider: provider, purpose: 'user-turn' }, { ...context }), AbortSignal.any([revoked.signal, ...(request.signal ? [request.signal] : [])])));
-                    await membership();
-                    if (!value || !('source' in value) || value.source !== 'host' || value.instanceId !== context.instanceId || value.epoch !== context.epoch || value.sessionId !== request.sessionId || value.workspaceId !== context.workspaceId || value.bindingId !== context.expectedBindingId || !Number.isSafeInteger(value.bindingRevision) || value.bindingRevision < 1 || (!value.target || !value.target.session || !sameTarget(trusted, value.target)) || physical(value.directory) !== stamp || value.project?.path !== value.directory.path || value.project?.name !== (basename(value.directory.path) || '/') || 'notice' in value && value.notice !== undefined)
-                        throw invalid();
-                    return value;
-                }
-                catch (error) {
-                    if (!request.signal?.aborted) {
-                        const cause = revoked.signal.reason;
-                        revoke(error);
-                        if (cause instanceof NeedError)
-                            throw cause;
-                    }
-                    throw error;
-                }
-            }
-        };
-    }
-    catch (error) {
-        dispose();
-        throw error;
-    }
+    const host = row.host?.host, path = request?.cwd ?? row.remote?.path;
+    if (typeof host !== 'string' || !host || !absoluteHostPath(path))
+        throw unavailable();
+    return Object.freeze({ source: 'host', host, path });
+}
+/** One L v2 resolution per user turn. L owns host/path checks and the current SSH target. */
+export async function resolveHostWorkspace(api, request, provider) {
+    const source = request.workspaceSource;
+    if (source?.source !== 'host')
+        throw unavailable();
+    if ((api.getContractInfo().hostWorkspaceResolution ?? 0) < 2)
+        throw new NeedError('DEPENDENCY_REQUIRED', '我需要更新远程主机连接组件后再使用主机目录；本轮未执行，原话保留。', 'L >=0.7.29 / hostWorkspaceResolution >=2');
+    return unwrap(await awaitL(() => api.resolveSessionProject(request.sessionId, { provider, purpose: 'user-turn' }, { ...source }), request.signal));
 }

package/dist/index.d.ts

@@ -74,8 +74,8 @@ export declare class CodexRemoteAdapter extends LlmAdapter {
     listModels(provider: string): Promise<(LlmResolvedModelInfo & {
         catalog: HostModel;
     })[]>;
-    resolveModel(provider: string, id: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
-    prepareCall(provider: string, id: string, _signal?: AbortSignal): Promise<{
+    resolveModel(provider: string, id: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, id: string, signal?: AbortSignal): Promise<{
         model: LlmResolvedModelInfo;
         stream: (options: GenerateOptions) => AsyncGenerator<StreamChunk, any, any>;
     }>;

package/dist/index.js

@@ -22,12 +22,13 @@ import { ModelPresentation } from "./model-presentation.js";
 import { EMPLOYEE_EXECUTION_NOTICE } from "./employee-presentation.js";
 import { ModelConfigurationError } from "./model-configuration.js";
 import { officialEmployeeWorkspace } from "./employee-workspace.js";
+import { createSessionSources } from "./session-source.js";
 import { resolveEmployeeNative } from "./employee-native.js";
 import { createClaudeLocalProvider } from "./claude-local.js";
 import { readLocalUserTurn } from "./local-user-turn.js";
 import { readEmployeeWorkspace } from "./employee-workspace.js";
 import { createPreflightDiagnostics } from "./preflight-diagnostic.js";
-import { installModelInputRetention } from "./model-input-retention.js";
+import { installModelInputRetention, markModelPreparationFailure } from "./model-input-retention.js";
 import { dshPermissionSource, permissionMode } from "./permissions.js";
 export { readDshPermissions } from "./permissions.js";
 export const name = 'ai-workbench-remote-agent';
@@ -121,8 +122,33 @@ export class CodexRemoteAdapter extends LlmAdapter {
     finally {
         catalog.release();
     } }
-    async resolveModel(provider, id, _signal) { return this.modelPresentation.resolve(provider, id) ?? { provider, id, name: id }; }
-    async prepareCall(provider, id, _signal) { return { model: await this.resolveModel(provider, id), stream: (options) => this.stream(options) }; }
+    async resolveModel(provider, id, signal) {
+        const displayed = this.modelPresentation.resolve(provider, id);
+        if (displayed)
+            return displayed;
+        const active = signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal;
+        const catalog = await this.catalog(active);
+        try {
+            active.throwIfAborted();
+            this.modelPresentation.remember(catalog);
+            const resolved = this.modelPresentation.resolve(provider, id);
+            if (!resolved)
+                throw new LlmError('所选模型当前不可用，请打开模型菜单重新选择。', 'MODEL_CATALOG_UNAVAILABLE');
+            return resolved;
+        }
+        finally {
+            catalog.release();
+        }
+    }
+    async prepareCall(provider, id, signal) {
+        try {
+            return { model: await this.resolveModel(provider, id, signal), stream: (options) => this.stream(options) };
+        }
+        catch (error) {
+            markModelPreparationFailure(provider, error, signal);
+            throw error;
+        }
+    }
     providerRetryPolicy() { return { mode: 'normal', maxRetries: 0, retryableCodes: [], initialDelayMs: 0, maxDelayMs: 0, jitterRatio: 0 }; }
     cleanupRuntime(runtime, cause = { layer: 'adapter', initiator: 'adapter.cleanup-runtime', reason: 'RUNTIME_CLEANUP', action: 'dispose' }) {
         runtime.closeDiagnostics?.record(cause);
@@ -253,7 +279,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
             const missingPointer = !!last && !previous;
             live = undefined;
             const configuration = JSON.stringify([config.acpMaxMessageBytes, config.brokerMaxFrameBytes, config.brokerControlMaxBytes, config.employeeShellKillGraceMs]);
-            Object.assign(request, { acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, sessionId: options.sessionId, mode, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) });
+            Object.assign(request, { acpMaxMessageBytes: config.acpMaxMessageBytes, resumeSessionId: previous?.sessionId, sessionId: options.sessionId, mode, hostSource: previous?.hostSource, cwd: previous?.cwd, identity: previous?.identity, bindingId: previous?.bindingId, workspaceId: previous?.workspaceId, agent: this.agent, signal, brokerSettings: Object.freeze({ brokerMaxFrameBytes: config.brokerMaxFrameBytes, brokerControlMaxBytes: config.brokerControlMaxBytes }) });
             request.previousContextSha256 = previous?.contextSha256;
             const after = options.messages.findLastIndex(message => message.role === 'assistant');
             const tail = options.messages.slice(after + 1);
@@ -298,13 +324,7 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 request.signal = modelSignal;
                 modelSignal.throwIfAborted();
             }
-            if (runtime.contextSignal) {
-                modelSignal = AbortSignal.any([modelSignal, runtime.contextSignal]);
-                options.signal = modelSignal;
-                request.signal = modelSignal;
-                modelSignal.throwIfAborted();
-            }
-            if (previous && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
+            if (previous && !runtime.hostSource && (previous.identity !== runtime.identity || previous.cwd !== runtime.cwd || previous.bindingId && previous.bindingId !== runtime.binding?.bindingId || previous.workspaceId && previous.workspaceId !== runtime.binding?.workspaceId))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '原会话的员工主机或工作区已改变，请新建会话', '原会话的可信目标和工作区');
             input = projectHostWorkspaceInput(input, runtime.hostWorkspace);
             if (runtime.hostWorkspace && mode === 'session' && Buffer.byteLength(JSON.stringify({ prompt: input.prompt, systemPrompt: input.systemPrompt }), 'utf8') > config.acpMaxMessageBytes)
@@ -506,17 +526,11 @@ export class CodexRemoteAdapter extends LlmAdapter {
                 }
             }
             yield* mapper.flush();
-            const pointer = { ...(modelConfiguration ? { modelConfiguration } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
+            const pointer = { ...(runtime.hostSource ? { hostSource: runtime.hostSource } : {}), ...(modelConfiguration ? { modelConfiguration } : {}), version: 2, agent: this.agent.id, contextSha256, ...(mode === 'session' ? { usageSnapshot: mapper.usageSnapshot } : {}), ...(options.sessionId ? { dshSessionId: options.sessionId } : {}), identity: runtime.identity, cwd: runtime.cwd, sessionId: id, ...(runtime.binding ? { bindingId: runtime.binding.bindingId, workspaceId: runtime.binding.workspaceId } : {}) };
             succeeded = true;
             yield { type: 'finish', reason: { kind: stop === 'max_tokens' || stop === 'max_turn_requests' ? 'max-tokens' : 'stop' }, replayState: { response: pointer } };
         }
         catch (error) {
-            // ACP cancellation must retain the source revocation that caused it.
-            // User cancellation and unrelated signals keep their existing semantics.
-            const sourceReason = runtime?.contextSignal?.aborted ? runtime.contextSignal.reason : undefined;
-            if (error instanceof NeedError && error.code === 'ABORTED' && sourceReason instanceof NeedError) {
-                error = Object.assign(new NeedError(sourceReason.code, sourceReason.message, sourceReason.requires), { ...(sourceReason.connectNeed ? { connectNeed: sourceReason.connectNeed } : {}), ...(sourceReason.officialReason ? { officialReason: sourceReason.officialReason } : {}), cause: new AggregateError([sourceReason, error], 'HOST_SOURCE_REVOKED') });
-            }
             turnFailure = error;
             runtime?.closeDiagnostics?.record({ layer: 'adapter', initiator: 'adapter.turn-failure', reason: closeCode(error, signal.aborted ? 'ABORTED' : 'TURN_FAILED'), action: 'failure' });
             recordInformation();
@@ -589,6 +603,7 @@ export function apply(ctx, live) {
         return manager;
     };
     ctx.provide('aiWorkbenchRemoteDiagnostics', { read: (query) => managerForProfile().read(query) });
+    const sessionSources = createSessionSources(ctx, get);
     const preflightDiagnostics = createPreflightDiagnostics({ ctx, getApi: get, manager: managerForProfile });
     const diagnostics = new Map();
     const diagnostic = (scope, provider, message) => {
@@ -641,7 +656,7 @@ export function apply(ctx, live) {
             const sessions = services.get('sessions');
             return officialEmployeeWorkspace(request.sessionId, registry, sessions?.get(request.sessionId)?.header);
         };
-        const provider = connectProvider(get, { agent, workspace, ...(agent.loginProvider === 'codex' ? { employee: {
+        const provider = connectProvider(get, { agent, workspace, source: sessionSources, ...(agent.loginProvider === 'codex' ? { employee: {
                     getNetwork: () => ctx.get('aiWorkbenchNetwork'),
                     workspace, native: () => resolveEmployeeNative(),
                 } } : {}), details, open, local });
@@ -665,12 +680,18 @@ export function apply(ctx, live) {
         }
         return managerForProfile().recordLoginFailure({ sessionId, code, diagnostic, context: { turn, step } });
     }, modelDirectory, preflightDiagnostics, dshPermissionSource(ctx));
-    for (const agent of AGENTS)
-        void adapter.listModels(agent.id).catch(() => ctx.logger('remote-agent').warn('模型列表暂不可用，打开菜单时可重新读取'));
     const ids = AGENTS.map(agent => agent.id);
     const entries = () => AGENTS.map(agent => ({ provider: agent.id, displayName: agent.name[language], settingsNs: actualSettingsNamespace ?? settingsNamespace, settingsPath: [] }));
     const directory = ctx.llm.registerConfigurableProviders(entries());
     const registration = ctx.llm.registerAdapter(ids, adapter);
+    let connection;
+    ctx.on('ai-workbench/connection-state', state => {
+        const previous = connection;
+        connection = state;
+        // Official replacement invalidates the browser's shared catalog and loads it.
+        if (state.phase === 'connected' && (previous?.phase !== 'connected' || previous.instanceId !== state.instanceId || previous.epoch !== state.epoch))
+            registration.replace(ids);
+    });
     installModelInputRetention(ctx, { isOurProvider: provider => ids.includes(provider), diagnosticForAttempt: position => preflightDiagnostics.forPreparation(position.sessionId, position), preflightDiagnostic: (provider, message) => diagnostic('preflight', provider, message), diagnostic: (provider, message) => diagnostic('input', provider, message) });
     const cleanup = async (id) => { try {
         await adapter.detachSession(id);

package/dist/preflight-diagnostic.js

@@ -49,7 +49,7 @@ export function createPreflightDiagnostics(options) {
                     const rows = state?.items.filter(row => row.workspaceId === workspace.id) ?? [];
                     if (state?.phase === 'ready' && state.instanceId === connection?.instanceId && state.epoch === connection.epoch && rows.length === 1) {
                         const row = rows[0];
-                        source = { workspaceId: row.workspaceId, bindingId: row.bindingId, source: row.source === 'local' || row.source === 'host' ? row.source : null, status: row.status };
+                        source = { workspaceId: row.workspaceId, bindingId: row.bindingId, source: row.source === 'local' || row.source === 'host' ? row.source : null, status: row.source === 'host' ? null : row.status ?? null };
                     }
                 }
             }

package/dist/presentation.d.ts

@@ -1,6 +1,5 @@
 /** Functional wording from connect-api appendix D1-D3 (L0.5.1 candidate). */
 export declare const REMOTE_CODEX_NAME = "Codex\uFF08\u8FDC\u7A0B\u4E3B\u673A\uFF09";
 export declare const CONNECTION_REQUIRED = "\u8FDC\u7A0B\u4E3B\u673A\u8FDE\u63A5\u7EC4\u4EF6\u6CA1\u6709\u88C5\u597D\uFF0C\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
-export declare const TEST_HOST_NOTICE = "\u8FDC\u7A0B\u4E3B\u673A\u6B63\u5728\u4F7F\u7528\u6D4B\u8BD5\u914D\u7F6E\uFF0C\u9047\u5230\u95EE\u9898\u8BF7\u8054\u7CFB\u7BA1\u7406\u5458\u3002";
 /** Employee failures use business language; diagnostic codes remain separately available. */
 export declare function employeeFailure(code: string, brand?: 'codex' | 'claude'): string;

package/dist/presentation.js

@@ -1,7 +1,6 @@
 /** Functional wording from connect-api appendix D1-D3 (L0.5.1 candidate). */
 export const REMOTE_CODEX_NAME = 'Codex（远程主机）';
 export const CONNECTION_REQUIRED = '远程主机连接组件没有装好，请联系管理员。';
-export const TEST_HOST_NOTICE = '远程主机正在使用测试配置，遇到问题请联系管理员。';
 /** Employee failures use business language; diagnostic codes remain separately available. */
 export function employeeFailure(code, brand = 'codex') {
     const messages = {
@@ -13,6 +12,7 @@ export function employeeFailure(code, brand = 'codex') {
         PERMISSION_POLICY_CHANGED: '当前权限已变化或无法核对，这次派发已停止；没有自动重发，你的原话仍保留，在途结果请查看技术详情。',
         APPROVAL_STALE: '连接或权限已变化，原审批已失效；没有自动重发，在途结果请查看技术详情。',
         PROJECT_BINDING_INVALID: '文件来源已改，请新建会话继续；原会话历史仍可查看。',
+        WORKSPACE_SOURCE_STORAGE_FAILED: '这条会话的文件来源未能保存，本轮工作区准备失败；请恢复后在原会话重试。',
         WORKSPACE_LOCATION_REQUIRED: '我需要你确认这个工作区使用哪一个文件夹，本轮未执行；你的原话仍保留。',
         WORKSPACE_LOCATION_CONFLICT: '工作区来源选择已更新，本次确认不能覆盖新的选择；本轮未执行，你的原话仍保留。',
         LOCAL_USER_TURN_CHANGED: '本次输入已变化，本轮已停止，请确认对话后重新发送。',

package/dist/provider.d.ts

@@ -1,3 +1,4 @@
+import { type SessionSource } from './host-workspace.ts';
 import type { CloseCause, CloseDiagnostics } from './close-diagnostics.ts';
 import type { AgentApp } from '@agentclientprotocol/sdk';
 import type { AgentApp as ExtendedAgentApp } from '@agentclientprotocol/sdk/unstable';
@@ -27,7 +28,9 @@ export interface Runtime {
     identity: string;
     cwd: string;
     hostWorkspace?: Readonly<HostWorkspacePresentation>;
-    contextSignal?: AbortSignal;
+    hostSource?: Extract<SessionSource, {
+        source: 'host';
+    }>;
     execution?: EmployeeExecution;
     acpTransport?: {
         writable: WritableStream<Uint8Array>;
@@ -61,6 +64,10 @@ export interface Runtime {
     closeDiagnostics?: CloseDiagnostics;
 }
 export interface RuntimeRequest extends Invocation {
+    workspaceSource?: SessionSource;
+    hostSource?: Extract<SessionSource, {
+        source: 'host';
+    }>;
     closeDiagnostics?: CloseDiagnostics;
     previousContextSha256?: string;
     preflightFailureRecorded?: boolean;
@@ -89,18 +96,6 @@ export type RuntimeProvider = ((request: RuntimeRequest) => Promise<Runtime>) &
     preflight?: (request: RuntimeRequest) => Promise<void>;
 };
 export interface ConnectTarget {
-    hostContext?: {
-        enforcement: 'production' | 'test';
-        checkExitCode: 0 | 1;
-        failedChecks: {
-            id: string;
-            status: string;
-        }[];
-        unverifiedChecks: {
-            id: string;
-            status: string;
-        }[];
-    };
     host: string;
     username: string;
     port: number;
@@ -165,8 +160,6 @@ declare module '@deepseek-ai/cordis' {
 export declare function awaitL<T>(operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
 export declare function unwrap<T>(result: Result<T>): T;
 export declare function validateTarget(t: ConnectTarget): void;
-/** Only the declared public check identifiers/statuses, never provider evidence. */
-export declare function hostContextNotice(t: ConnectTarget): string | undefined;
 export declare function identity(t: ConnectTarget): string;
 /** Reject draft.3 and legacy runtime rather than inventing workspace bindings. */
 export declare function requireNativeWorkspace(api: ConnectApi): asserts api is ConnectApi & NativeWorkspaceApi;
@@ -183,6 +176,7 @@ export declare function connectProvider(get: () => ConnectApi | undefined, optio
         id: string;
         path: string;
     }>;
+    source?: (request: RuntimeRequest, api: ConnectApi) => Promise<SessionSource | undefined>;
     employee?: EmployeeProviderOptions;
     local?: LocalRuntimeProvider;
     details?: (request: RuntimeRequest, api: ConnectApi, connection: ConnectionState, target: ConnectTarget) => Promise<DetailChannel>;

package/dist/provider.js

@@ -1,8 +1,8 @@
-import { hostWorkspaceGuard } from "./host-workspace.js";
+import { resolveHostWorkspace, workspaceSessionSource } from "./host-workspace.js";
 import { connectNeedError } from "./connect-need.js";
 import { loginDiagnostic, loginReason } from "./login-diagnostic.js";
 import { NeedError } from "./remote.js";
-import { CONNECTION_REQUIRED, TEST_HOST_NOTICE } from "./presentation.js";
+import { CONNECTION_REQUIRED } from "./presentation.js";
 import { CODEX_AGENT } from "./agents.js";
 export function requireLoginCoordinator(api) {
     if (!['getConnectionState', 'getLoginPromptState', 'requestLoginPrompt', 'refreshLoginPrompts'].every(key => typeof api[key] === 'function'))
@@ -118,19 +118,6 @@ export function validateTarget(t) {
         || ![t.projectRoot, t.session.command, t.session.root, t.session.settingsPath].every(p => typeof p === 'string' && p.startsWith('/'))) {
         throw new NeedError('CONNECT_API_MISMATCH', '我需要 connect-api 0.3.0 的可信主机、项目和 session 能力；旧目标不能继续使用', 'L 提供的完整 0.3.0 目标');
     }
-    hostContextNotice(t);
-}
-/** Only the declared public check identifiers/statuses, never provider evidence. */
-export function hostContextNotice(t) {
-    const h = t.hostContext;
-    if (h === undefined)
-        return;
-    const checks = (items) => Array.isArray(items) && items.every(item => item && typeof item.id === 'string' && typeof item.status === 'string');
-    if (!h || (h.enforcement !== 'test' && h.enforcement !== 'production') || (h.checkExitCode !== 0 && h.checkExitCode !== 1) || !checks(h.failedChecks) || !checks(h.unverifiedChecks))
-        throw new NeedError('CONNECT_API_MISMATCH', '主机检查背景无效，不能假定已通过生产检查', 'L 提供的有效 hostContext');
-    if (h.enforcement !== 'test')
-        return;
-    return TEST_HOST_NOTICE;
 }
 export function identity(t) { return `${t.username}@${t.host}:${t.port}`; }
 /** Reject draft.3 and legacy runtime rather than inventing workspace bindings. */
@@ -158,30 +145,6 @@ export function sameTarget(a, b) {
 }
 export function connectProvider(get, options = {}) {
     const agent = options.agent ?? CODEX_AGENT;
-    const hostScopes = new WeakMap();
-    const hostMethods = new WeakMap();
-    const retainHostScope = (runtime, scope) => {
-        hostScopes.get(runtime)?.dispose();
-        hostScopes.set(runtime, scope);
-        runtime.contextSignal = scope.revocation;
-        if (hostMethods.has(runtime))
-            return;
-        const original = { dispose: runtime.dispose, detach: runtime.detach };
-        hostMethods.set(runtime, original);
-        const release = () => { hostScopes.get(runtime)?.dispose(); hostScopes.delete(runtime); };
-        runtime.dispose = async (cause) => { try {
-            await original.dispose?.(cause);
-        }
-        finally {
-            release();
-        } };
-        runtime.detach = async (cause) => { try {
-            await original.detach?.(cause);
-        }
-        finally {
-            release();
-        } };
-    };
     // Keep the legacy source SDK wrapper's strip-only import graph free of broker runtime syntax.
     // Cache the initialization promise so concurrent sessions share this provider's binding lifetimes.
     let employee;
@@ -195,7 +158,13 @@ export function connectProvider(get, options = {}) {
         requireLoginCoordinator(api);
         let sourceStage = 'input-acceptance';
         try {
-            if (options.employee) {
+            request.workspaceSource = options.source ? await options.source(request, api) : request.hostSource;
+            if (!options.source && !request.workspaceSource && options.workspace && request.sessionId && api.getContractInfo().workspaceLocations === 1) {
+                const workspace = await options.workspace(request);
+                request.workspaceSource = workspaceSessionSource(api, workspace.id, request);
+            }
+            const host = request.workspaceSource?.source === 'host';
+            if (options.employee && !host) {
                 const module = await import("./employee-provider.js");
                 request.localContext = await module.inspectEmployeeWorkspace(get, options.employee, agent, api, request);
             }
@@ -211,15 +180,16 @@ export function connectProvider(get, options = {}) {
                 const connection = await waitForLogin(api, agent.loginProvider, before, get, request.signal);
                 return { target, connection };
             })();
-            if (request.identity && request.identity !== identity(target))
+            if (request.workspaceSource?.source !== 'host' && request.identity && request.identity !== identity(target))
                 throw new NeedError('SESSION_CONTEXT_MISMATCH', '员工主机与原会话不一致，请新建会话', '原员工主机');
             request.localAdmissionCheck?.();
             admissions.set(request, { api, target, connection });
             sourceStage = 'local-admission';
-            const locations = api.getContractInfo().workspaceLocations === 1 ? api.getWorkspaceLocationState?.() : undefined;
-            if (locations && (locations.phase === 'failed' || locations.phase === 'disposed') && locations.instanceId === connection.instanceId && locations.epoch === connection.epoch && locations.need)
+            const locations = !host && api.getContractInfo().workspaceLocations === 1 ? api.getWorkspaceLocationState?.() : undefined;
+            if (!host && locations && (locations.phase === 'failed' || locations.phase === 'disposed') && locations.instanceId === connection.instanceId && locations.epoch === connection.epoch && locations.need)
                 throw connectNeedError(locations.need);
-            await options.local?.admit?.(request, api, connection, target);
+            if (!host)
+                await options.local?.admit?.(request, api, connection, target);
         }
         catch (error) {
             admissions.delete(request);
@@ -238,59 +208,38 @@ export function connectProvider(get, options = {}) {
         const { api, target, connection } = admitted;
         if (!request.sessionId)
             throw new NeedError('PROJECT_BINDING_REQUIRED', '我需要当前会话和已选择的工作区，请使用原生工作区入口', 'DSH会话与原生工作区');
-        const host = await hostWorkspaceGuard(get, api, connection, target, request, options.workspace, agent.loginProvider);
-        try {
-            if (!host && options.employee) {
-                employee ??= import("./employee-provider.js").then(module => module.createEmployeeProvider(get, options, agent));
-                const local = await (await employee)({ api, target, connection, request });
-                if (local) {
-                    local.loginRequired = () => offerLogin(api, request, get, agent);
-                    return local;
-                }
-            }
-            if (!host && agent.loginProvider === 'claude' && options.local) {
-                const runtime = await options.local(request, api, connection, target);
-                if (runtime)
-                    return runtime;
-            }
-            // A local source must have been handled by its employee provider above.
-            // Host execution requires an explicit host location; no name-based resolver.
-            if (!host)
-                throw new NeedError('WORKSPACE_LOCATION_REQUIRED', '请选择文件夹来源；改变来源后请新建会话。', '已选择的本机或主机文件夹');
-            const resolved = await host.resolve();
-            const project = resolved.project;
-            if (request.cwd && request.cwd !== project.path || request.bindingId && request.bindingId !== resolved.bindingId || request.workspaceId && request.workspaceId !== resolved.workspaceId)
-                throw new NeedError(host ? 'PROJECT_BINDING_INVALID' : 'SESSION_CONTEXT_MISMATCH', host ? '文件来源已改，请新建会话继续；原会话历史仍可查看。' : '原会话的工作区绑定已改变，请新建会话', '原工作区绑定');
-            const details = await options.details?.(request, api, connection, target);
-            try {
-                if (!options.open)
-                    throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
-                const runtime = await options.open(resolved.target, project, { ...request, ...(host ? { signal: host.signal } : {}), agent, bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, bindingRevision: resolved.bindingRevision, detailChannel: details });
-                try {
-                    host?.observeRuntime(runtime);
-                }
-                catch (error) {
-                    void runtime.dispose?.().catch(() => console.warn('HOST_CLEANUP_FAILED'));
-                    throw error;
-                }
-                if (host)
-                    retainHostScope(runtime, host);
-                runtime.hostWorkspace = host && 'directory' in resolved ? Object.freeze({ cwd: resolved.directory.path }) : undefined;
-                // The transport can outlive a turn; presentation belongs only to this invocation.
-                runtime.details = details ?? runtime.details;
-                runtime.binding = { bindingId: resolved.bindingId, workspaceId: resolved.workspaceId, revision: resolved.bindingRevision };
-                runtime.connection = { ...connection };
-                runtime.loginRequired = () => offerLogin(api, request, get, agent);
-                return runtime;
-            }
-            catch (error) {
-                throw error;
+        const host = request.workspaceSource?.source === 'host';
+        if (!host && options.employee) {
+            employee ??= import("./employee-provider.js").then(module => module.createEmployeeProvider(get, options, agent));
+            const local = await (await employee)({ api, target, connection, request });
+            if (local) {
+                local.loginRequired = () => offerLogin(api, request, get, agent);
+                return local;
             }
         }
-        catch (error) {
-            host?.dispose();
-            throw error;
+        if (!host && agent.loginProvider === 'claude' && options.local) {
+            const runtime = await options.local(request, api, connection, target);
+            if (runtime)
+                return runtime;
         }
+        // A local source must have been handled by its employee provider above.
+        // Host execution requires an explicit host location; no name-based resolver.
+        if (!host)
+            throw new NeedError('WORKSPACE_LOCATION_REQUIRED', '请选择文件夹来源；改变来源后请新建会话。', '已选择的本机或主机文件夹');
+        const resolved = await resolveHostWorkspace(api, request, agent.loginProvider);
+        const project = resolved.project;
+        const details = await options.details?.(request, api, connection, target);
+        if (!options.open)
+            throw new NeedError('RUNTIME_REQUIRED', '我需要主机运行适配器', '主机broker适配');
+        const runtime = await options.open(resolved.target, project, { ...request, agent, bindingId: undefined, workspaceId: undefined, bindingRevision: undefined, detailChannel: details });
+        runtime.hostSource = Object.freeze({ ...request.workspaceSource });
+        runtime.hostWorkspace = Object.freeze({ cwd: project.path });
+        // The transport can outlive a turn; presentation belongs only to this invocation.
+        runtime.details = details ?? runtime.details;
+        runtime.binding = undefined;
+        runtime.connection = { ...connection };
+        runtime.loginRequired = () => offerLogin(api, request, get, agent);
+        return runtime;
     };
     resolve.preflight = preflight;
     return resolve;

package/dist/session-source.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type SessionSource } from './host-workspace.ts';
+import type { ConnectApi, RuntimeRequest } from './provider.ts';
+export declare const sessionSourceSpec: {
+    name: string;
+    version: number;
+    tables: {
+        sessions: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            source: "host";
+            host: string;
+            path: string;
+        } | {
+            source: "local";
+        }>;
+    };
+};
+/** Official domain metadata, keyed by native session ID. No L files, local path probes or host identity hashes. */
+export declare function createSessionSources(ctx: Context, getApi: () => ConnectApi | undefined): (request: RuntimeRequest, api: ConnectApi) => Promise<SessionSource | undefined>;

package/dist/session-source.js

@@ -0,0 +1,90 @@
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { z } from 'zod';
+import { absoluteHostPath, workspaceSessionSource } from "./host-workspace.js";
+import { NeedError } from "./remote.js";
+const sourceSchema = z.discriminatedUnion('source', [
+    z.object({ source: z.literal('host'), host: z.string().min(1), path: z.string().refine(absoluteHostPath) }).strict(),
+    z.object({ source: z.literal('local') }).strict(),
+]);
+export const sessionSourceSpec = defineDomain({ name: 'ai_workbench_remote_sources', version: 1, tables: { sessions: domainTable(sourceSchema) } });
+const storageNeed = () => new NeedError('WORKSPACE_SOURCE_STORAGE_FAILED', '这条会话的文件来源未能保存，本轮工作区准备失败；请恢复后在原会话重试。', '官方会话来源存储');
+/** Official domain metadata, keyed by native session ID. No L files, local path probes or host identity hashes. */
+export function createSessionSources(ctx, getApi) {
+    let domain;
+    const pending = new Map();
+    const captured = new WeakMap();
+    const open = () => {
+        if (!domain) {
+            const facility = ctx.get('storageDomain');
+            if (!facility)
+                throw storageNeed();
+            domain = facility.open(sessionSourceSpec).catch(error => { domain = undefined; throw error; });
+        }
+        return domain;
+    };
+    ctx.effect(() => async () => { if (domain)
+        await (await domain).close(); });
+    function candidate(session, api, request) {
+        if (request?.hostSource)
+            return sourceSchema.parse(request.hostSource);
+        const registry = ctx.get('workspaceRegistry');
+        // Creation can precede workspace membership publication. The official creation cwd identifies its workspace.
+        const rows = registry?.list().filter(row => request?.workspaceId ? row.id === request.workspaceId : row.sessionIds.includes(session.id) || row.path === session.header.cwd) ?? [];
+        if (rows.length !== 1)
+            return;
+        return workspaceSessionSource(api, rows[0].id, request);
+    }
+    function save(session, api, request) {
+        const id = session.id, existing = pending.get(id);
+        if (existing)
+            return existing;
+        const work = async () => {
+            const table = (await open()).table('sessions'), stored = table.get(id);
+            if (stored) {
+                const source = Object.freeze({ ...stored });
+                captured.set(session, source);
+                return source;
+            }
+            const chosen = captured.get(session) ?? candidate(session, api, request);
+            if (!chosen)
+                return;
+            captured.set(session, chosen);
+            await table.put(id, chosen);
+            return chosen;
+        };
+        const result = work().catch(error => { if (error instanceof NeedError)
+            throw error; throw Object.assign(storageNeed(), { cause: error }); });
+        pending.set(id, result);
+        void result.finally(() => pending.delete(id)).catch(() => { });
+        return result;
+    }
+    ctx.on('session/created', session => {
+        // Restored sessions migrate from their recorded replay/workspace at first turn.
+        if (session.firstLiveSeq !== 0)
+            return;
+        const api = getApi();
+        if (!api)
+            return;
+        try {
+            const source = candidate(session, api);
+            if (source)
+                captured.set(session, source);
+        }
+        catch {
+            ctx.logger('remote-agent').warn('创建时文件来源暂不可读；发送时将重试');
+            return;
+        }
+        if (!captured.has(session))
+            return;
+        void save(session, api).catch(() => ctx.logger('remote-agent').warn('会话文件来源暂未保存；发送时将重试'));
+    });
+    return async (request, api) => {
+        if (!request.sessionId || api.getContractInfo?.().workspaceLocations !== 1 && !request.hostSource)
+            return;
+        const session = ctx.get('sessions')?.get(SessionId(request.sessionId));
+        if (!session)
+            throw storageNeed();
+        return save(session, api, request);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-workbench/remote-agent",
-  "version": "0.8.23",
+  "version": "0.8.25",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,7 +36,7 @@
     "zod": "4.6.7"
   },
   "devDependencies": {
-    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.27.tgz",
+    "@ai-workbench/connect": "file:test/fixtures/ai-workbench-connect-0.7.29.tgz",
     "@ai-workbench/network": "file:test/fixtures/ai-workbench-network-0.4.9.tgz",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/cordis-plugin-group": "1.0.4",
@@ -63,10 +63,11 @@
     "react-dom": "18.3.1",
     "typescript": "5.9.3",
     "zustand": "4.4.7",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "0.2.0-rc.2"
   },
   "peerDependencies": {
-    "@ai-workbench/connect": "~0.7.27",
+    "@ai-workbench/connect": "~0.7.29",
     "@ai-workbench/network": "~0.4.9",
     "@deepseek-ai/cordis": "4.0.4",
     "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
@@ -76,7 +77,8 @@
     "@deepseek-ai/dsh-typert-protocol": "0.2.0-rc.2",
     "@deepseek-ai/dsh-user-approval": "0.2.0-rc.2",
     "@deepseek-ai/schemastery": "3.18.4",
-    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2"
+    "@deepseek-ai/dsh-sandbox-policy": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-storage-domain": "0.2.0-rc.2"
   },
   "dsh": {
     "bundle": {