@ai-workbench/remote-agent 0.8.24 → 0.8.26

package/README.md

@@ -1,12 +1,16 @@
-# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.24 · 插件 → 添加插件
+# AI Workbench 远程助手 · @ai-workbench/remote-agent@0.8.26 · 插件 → 添加插件
 
 通过官方 DSH 插件入口使用 Claude（远程主机）与 Codex（远程主机）。登录和工作区来源由“远程主机连接”组件提供；员工在原生工作区和模型菜单中选择文件夹与型号。
 
-文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，不自动迁移旧会话的来源。
+文件和命令在所选的本机或主机目录执行，订阅凭据留在主机。插件不改写 DSH 的默认模型，不为员工创建同名主机目录，已有主机会话只提取一次原有主机来源并保存。
+
+需要远程主机连接组件 0.7.29 或更新的 0.7.x，以及联网助手 0.4.9。主机来源保存于官方 storage.domain 的会话元数据表，每轮仅由连接组件检查一次主机目录，不检查本机占位目录。
+
+Claude 本机 Bash 会单独消费员工桥代理的控制诊断，不把它交给模型当作命令输出；真实传输中断仍提示结果未知。命令自身的标准输出、标准错误与退出码照常返回。
 
 ## 会话行为
 
-每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。改变文件来源后请新建会话。
+每轮启动一个新助手进程，按原生会话编号恢复上下文；不接回旧进程或重放上一轮输入。主机会话始终使用创建时保存的主机和目录；工作区之后的选择只影响新会话。
 
 断线会结束本轮；操作可能已部分执行，请先检查文件。恢复连接后可在原会话继续。旧进程清理和技术详情记录尽力而为，不阻止下一轮。原生本机会话恢复的兼容性及实际设备结果见本轮交付证据，未验证项不作为已通过。
 
@@ -17,7 +21,7 @@ DSH 启动和打开模型菜单时读取一次主机型号列表。发送时不
 - 员工选本机文件夹，就在员工电脑上执行；通道失败不会改在主机运行。
 - 订阅凭据留在主机，不放进命令参数、日志或技术详情。
 - 跟随 DSH 当前权限：完全权限不问、工作区内修改先问、仅可查看只读。需要审批时使用官方卡片。
-- 一条会话对应一个工作区来源；换来源请新建会话。
+- 一条会话对应一个文件来源；主机来源不会随工作区后续选择改变，本机来源继续沿用原生绑定。
 
 Codex 员工端只使用随包提供的原生组件，通道等待本次组件的启动标记后才完成开通，不逐通道执行摘要或版本校验。当前员工端支持范围以发布验证记录为准，不让员工手填执行器路径。
 
@@ -40,7 +44,7 @@ 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“打开配置文件”入口。
 

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-shell.d.ts

@@ -1,4 +1,4 @@
-import { type CloseDiagnostics } from './close-diagnostics.ts';
+import type { CloseDiagnostics } from './close-diagnostics.ts';
 import type { ChildProcessWithoutNullStreams } from 'node:child_process';
 import type { EmployeeEndpointTarget } from './employee-endpoint.ts';
 export interface EmployeeShellResult {

package/dist/employee-shell.js

@@ -1,19 +1,35 @@
-import { closeCode } from "./close-diagnostics.js";
 import { randomUUID } from 'node:crypto';
 import { EMPLOYEE_PYTHON_ERRORS } from "./employee-relay.js";
 import { NeedError } from "./remote.js";
 const SHELL_PYTHON = String.raw `
-import sys,json,subprocess,shlex
+import sys,json,subprocess,shlex,tempfile,signal,re
 def fail(code):
  sys.stderr.write(json.dumps({"code":code})+"\n");sys.exit(254)
 try:
- x=json.loads(sys.argv[1]);e=x["endpoint"];args=x["sshArgs"];cwd=x["cwd"]
+ x=json.loads(sys.argv[1]);e=x["endpoint"];args=list(x["sshArgs"]);cwd=x["cwd"]
+ proxy=[i for i,arg in enumerate(args) if arg.startswith("ProxyCommand=")]
+ if len(proxy)!=1:fail("EMPLOYEE_BRIDGE_PROTOCOL_INVALID")
  # User source is stdin, never argv. The sentinel preserves trailing newlines.
  wrapper="cd -- "+shlex.quote(cwd)+" || exit 254; "+"printf '%s\\n' "+shlex.quote('AW_EMPLOYEE_SHELL_STARTED '+x['executionId'])+" >&2; "+'aw_x_source=$(/bin/cat; printf x); aw_x_source='+chr(36)+'{aw_x_source%?}; eval "'+chr(36)+'aw_x_source"'
  command=shlex.join([e["endpointShell"],"-c",wrapper])
  sys.stderr.write("AW_EMPLOYEE_SHELL_READY "+x["executionId"]+"\n");sys.stderr.flush()
- p=subprocess.Popen(["/usr/bin/ssh","-T"]+args+[command],stdin=sys.stdin,stdout=sys.stdout,stderr=sys.stderr)
- code=p.wait();sys.exit(code if code>=0 else 255)
+ # OpenSSH inherits ProxyCommand fd2 into its combined stderr. Separate that
+ # producer before launch; never inspect/filter the employee command's bytes.
+ def interrupted(signum,frame):
+  raise SystemExit(255)
+ for sig in [signal.SIGTERM,signal.SIGHUP,signal.SIGINT]:signal.signal(sig,interrupted)
+ with tempfile.NamedTemporaryFile(prefix="aw-x-bridge-") as diagnostic:
+  # S already escaped its own percent tokens. Only escape the added path.
+  i=proxy[0];args[i]+=" 2>"+shlex.quote(diagnostic.name.replace("%","%%"))
+  p=subprocess.Popen(["/usr/bin/ssh","-T"]+args+[command],stdin=sys.stdin,stdout=sys.stdout,stderr=sys.stderr)
+  code=p.wait()
+  diagnostic.seek(0)
+  # S's raw CLI emits at most one fixed error line, never arbitrary diagnostics.
+  raw=diagnostic.read(x["maxBytes"]+1)
+  match=re.fullmatch(rb"BRIDGE_ERROR ([A-Z][A-Z0-9_]{0,63})\n",raw)
+  bridge_code=match.group(1).decode("ascii") if match else None
+  sys.stderr.write("\nAW_EMPLOYEE_BRIDGE_RESULT "+x["executionId"]+" "+json.dumps(bridge_code)+"\n");sys.stderr.flush()
+ sys.exit(code if code>=0 else 255)
 ` + EMPLOYEE_PYTHON_ERRORS;
 const unknown = (code) => new NeedError(code, '本机命令结果未知；没有重放，也未改在主机执行。', '员工端真实退出回执');
 /** Use only the target verified at this round lease opening. Cancellation cannot prove remote exit. */
@@ -22,11 +38,10 @@ export function createEmployeeShell(options) {
         signal.throwIfAborted();
         const diagnostics = options.closeDiagnostics?.child();
         const executionId = randomUUID(), target = options.target;
-        const child = await options.attach({ command: '/usr/bin/python3', args: ['-c', SHELL_PYTHON, JSON.stringify({ endpoint: target.endpoint, sshArgs: options.sshArgs, cwd: target.local.directory.path, executionId })] });
+        const child = await options.attach({ command: '/usr/bin/python3', args: ['-c', SHELL_PYTHON, JSON.stringify({ endpoint: target.endpoint, sshArgs: options.sshArgs, cwd: target.local.directory.path, executionId, maxBytes: options.maxBytes })] });
         return new Promise((yes, no) => {
             let settled = false, bytes = 0, stdout = [], stderr = [], reason, grace, timer;
-            const finish = (error, code) => {
-                diagnostics?.record({ layer: 'executor', initiator: 'shell.finish', reason: closeCode(error, 'SHELL_FINISHED'), action: 'close', exitCode: code ?? null, changes: [{ field: 'shell.settled', before: settled, after: true }] });
+            const finish = (error, code, exitSignal) => {
                 if (settled)
                     return;
                 settled = true;
@@ -39,6 +54,7 @@ export function createEmployeeShell(options) {
                 child.stdout.destroy();
                 child.stderr.destroy();
                 if (error) {
+                    diagnostics?.record({ layer: 'executor', initiator: 'shell.finish', reason: error.code, action: 'failure', exitCode: code ?? null });
                     no(error);
                     return;
                 }
@@ -51,6 +67,23 @@ export function createEmployeeShell(options) {
                     no(unknown('EMPLOYEE_OUTPUT_BINARY_UNSUPPORTED'));
                     return;
                 }
+                const trailer = '\nAW_EMPLOYEE_BRIDGE_RESULT ' + executionId + ' ', end = err.lastIndexOf(trailer);
+                let bridgeCode;
+                if (end >= 0) {
+                    try {
+                        const value = JSON.parse(err.slice(end + trailer.length));
+                        if (typeof value === 'string' && /^[A-Z][A-Z0-9_]{0,63}$/.test(value))
+                            bridgeCode = value;
+                        else if (value !== null)
+                            throw Error();
+                        err = err.slice(0, end);
+                    }
+                    catch {
+                        no(unknown('EMPLOYEE_EXIT_UNKNOWN'));
+                        return;
+                    }
+                }
+                diagnostics?.record({ layer: 'relay', initiator: 'shell.process-close', reason: 'PROCESS_EXIT', action: 'exit', exitCode: code ?? null, signal: exitSignal ?? null, ...bridgeCode ? { remoteReason: bridgeCode } : {} });
                 const header = 'AW_EMPLOYEE_SHELL_READY ' + executionId + '\n', started = 'AW_EMPLOYEE_SHELL_STARTED ' + executionId + '\n';
                 const start = err.indexOf(started, header.length);
                 if (!err.startsWith(header) || start < header.length || start > header.length && err[start - 1] !== '\n') {
@@ -62,11 +95,11 @@ export function createEmployeeShell(options) {
                             source = parsed.code;
                     }
                     catch { /* Never expose arbitrary transport diagnostics. */ }
-                    no(unknown(source ?? 'EMPLOYEE_EXIT_UNKNOWN'));
+                    no(unknown(bridgeCode ?? source ?? 'EMPLOYEE_EXIT_UNKNOWN'));
                     return;
                 }
-                if (code === null || code === undefined || code === 255) {
-                    no(unknown('EMPLOYEE_EXIT_UNKNOWN'));
+                if (code === null || code === undefined || code === 255 || end < 0) {
+                    no(unknown(bridgeCode ?? 'EMPLOYEE_EXIT_UNKNOWN'));
                     return;
                 }
                 yes({ stdout: out, stderr: err.slice(header.length, start) + err.slice(start + started.length), stderrSource: 'combined-ssh-and-command', exitCode: code, signal: null });
@@ -85,7 +118,7 @@ export function createEmployeeShell(options) {
             child.stderr.on('data', (b) => collect(stderr, b));
             child.stdin.on('error', () => stop('EMPLOYEE_INPUT_UNKNOWN'));
             child.once('error', () => { diagnostics?.record({ layer: 'relay', initiator: 'shell.process-error', reason: 'EMPLOYEE_TRANSPORT_UNKNOWN', action: 'failure' }); finish(unknown('EMPLOYEE_TRANSPORT_UNKNOWN')); });
-            child.once('close', (code, exitSignal) => { diagnostics?.record({ layer: 'relay', initiator: 'shell.process-close', reason: reason?.code ?? 'PROCESS_EXIT', action: 'exit', exitCode: code, signal: exitSignal }); finish(reason, code); });
+            child.once('close', (code, exitSignal) => finish(reason, code, exitSignal));
             signal.addEventListener('abort', abort, { once: true });
             if (signal.aborted)
                 abort();

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.js

@@ -22,6 +22,7 @@ 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";
@@ -278,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);
@@ -323,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)
@@ -531,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();
@@ -614,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) => {
@@ -666,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 });

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.js

@@ -12,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;
@@ -169,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,4 +1,4 @@
-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";
@@ -145,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;
@@ -182,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);
             }
@@ -198,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);
@@ -225,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.24",
+  "version": "0.8.26",
   "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": {