@ai-workbench/remote-agent 0.8.15 → 0.8.17

package/README.md

@@ -1,10 +1,10 @@
-**`@ai-workbench/remote-agent@0.8.15` 发布形态包。模型菜单逐项解析与同次展示目录保持一致；失效选择明确提示重新选择，发送准备和每轮发送仍独立查可信目录。模型型号、推理等级和来源只进技术详情；本机执行说明每个会话首次一句，完整限制可在技术详情查阅。编排已回证0.8.14 Claude在leo本地文件夹首轮成功；0.8.15仍待真机复验，Codex历史EMPLOYEE_EXEC_CLOSED根因仍未查明。X2出固定包及SHA，不publish。通过官方插件 → 添加插件安装，由编排发布；X2不publish。**
+**`@ai-workbench/remote-agent@0.8.17` 发布形态包。Claude、Codex 接入 L0.7.20 已选择的主机文件夹；成功核验来源和目录后才打开技术详情与派发，每次派发前重新核验。L 的具体原因和下一步动作直接给员工。包含0.8.16首次关闭、运行、诊断保存和清理结果留痕；历史原始撤销字段与61秒慢查询根因仍未查明。本版 leo 主机位置/真实员工链路尚未复验。通过官方插件 → 添加插件安装；固定包由编排发布，X2 不 publish。**
 
 # 远程ACP插件
 
 一个插件提供 **Claude（远程主机）** 和 **Codex（远程主机）**，通过员工主机上的官方CLI运行。Codex保留单次模式；Claude固定会话模式。只用官方模型列表、插件管理和配置入口，不提供自制面板、问答或登录按钮。登录和原生工作区绑定唯一归连接插件L。
 
-当前版本号为0.8.15；包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.19固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.19`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
+当前版本0.8.17，由X2按编排裁定基于0.8.16交付主机来源执行和L具体Need透传；包名采用`@ai-workbench/remote-agent`以涵盖两个品牌；本轮按编排放行准备发布形态包，供 leo 真机自验；X 不执行实际发布，由编排统一发布。开发fixture逐字节保留L0.7.20固定包，公开类型与SSH导出从该包消费。运行时仍要求L的`getContractInfo()`同时返回API0.7.0、implemented、native-local-v1；旧L包、draft.3或只有版本号的不完整实现会明确报缺项。依赖范围为`~0.7.20`，L由官方插件管理单独安装，不打进X。组件验证不代表真实开通、模型或leo E通过；HanaMesh另验。
 
 已包含L0.7.18消费增量：来源确认、输入接纳、登录、本机接纳、输入准备、模型目录及运行时解析的早期失败，用正式`preflightDiagnostics:1` / `preflight-check`进入L「连接前技术详情（含登录与工作区确认）」。阶段、真实来源/状态和错误代码可展开；未知来源为null，旧login-check的完整安全原因保留。记录不选择来源、不接纳输入、不自动重发；无原生会话的菜单查询仍在模型设置报告。当前工程和设置组件验证不等于leo GUI验收。
 
@@ -12,7 +12,11 @@
 
 ## 员工路径
 
-从官方插件管理安装，照常使用默认工作区/会话/模型入口。L0.7.17沿唯一“远程主机连接”设置节记录文件来源；主机来源沿用L既有解析；本地来源接入N0.4.4/S0.4.11员工端点。旧映射可在本轮官方一次确认中选择改用本机文件夹；拒绝、取消或输入/来源变化时不切换、不执行。也可在L设置逐工作区确认沿用原主机关联，新主机位置仍按L现有合同停止为WORKSPACE_LOCATION_PROVIDER_REQUIRED。本地六类工具经Claude公开toolAliases路由到员工电脑：cwd是员工选定目录，Git使用本机仓库，不回退主机同名目录。本地真实员工输入先取得官方当前轮次CAS预期，再调用L0.7.17 acceptLocalWorkspaceUserTurn；核回包后才打开D19和本轮主机目录/执行。每轮localAcceptanceId冻结进原详情sink，迟到结果不借新轮ID；LOCAL_USER_TURN_CHANGED立即停止本轮，不重接纳或退legacy。已用固定真包完成本地D19组件联测；编排已回证0.8.14 Claude/Opus5/Default在leo本地目录首轮写文件成功；该回证不覆盖本0.8.15或Codex，产品验收以各版本leo实际结果为准。本地文件不自动上传，X不猜目录、不选首项。首次说明使用官方普通回复；先经官方会话提交、持久化并读回核对，才向L确认。持久记录不等于员工已看见，GUI另验；日志丢失后的未知claim由L保留，不宣称端到端恰好一次。
+从官方插件管理安装，照常使用默认工作区/会话/模型入口。L沿唯一“远程主机连接”设置节记录文件来源；L0.7.20新选主机位置由两品牌按已核验的规范目录执行，旧legacy主机绑定仍沿原规则；本地来源接入N0.4.4/S0.4.11员工端点。旧映射可在本轮官方一次确认中选择改用本机文件夹；拒绝、取消或输入/来源变化时不切换、不执行。也可在L设置逐工作区确认沿用原主机关联。缺正式host解析能力时明确说明所缺组件、保留原话，本轮不派发。本地六类工具经Claude公开toolAliases路由到员工电脑：cwd是员工选定目录，Git使用本机仓库，不回退主机同名目录。本地真实员工输入先取得官方当前轮次CAS预期，再调用L0.7.17 acceptLocalWorkspaceUserTurn；核回包后才打开D19和本轮主机目录/执行。每轮localAcceptanceId冻结进原详情sink，迟到结果不借新轮ID；LOCAL_USER_TURN_CHANGED立即停止本轮，不重接纳或退legacy。已用固定真包完成本地D19组件联测；编排已回证0.8.14 Claude/Opus5/Default在leo本地目录首轮写文件成功；该回证不覆盖本0.8.17或Codex，产品验收以各版本leo实际结果为准。本地文件不自动上传，X不猜目录、不选首项。首次说明使用官方普通回复；先经官方会话提交、持久化并读回核对，才向L确认。持久记录不等于员工已看见，GUI另验；日志丢失后的未知claim由L保留，不宣称端到端恰好一次。
+
+新主机位置允许当前SSH员工账号可访问的已选绝对目录、文件系统根目录、非Git或只读目录；不改写原projectRoot、不创建Git、不转本机同名文件夹。read/execute必须可核实，write=false不额外一刀切拒绝，实际写入服从主机系统权限。运行前必核来源UUID、连接代次、目录及链接入口dev/ino和权限；revision与内容增删导致的mtime/ctime变化不单独失效。此核对属于正确性条件，不可关闭。最后inspect到主机spawn之间仍有OS时序边界，不表示原子目录句柄租约。
+
+文件来源或位置改变后，原会话不能改绑或重放，员工看到“文件来源已改，请新建会话继续”；原会话历史仍可查。L的具体Need保留message/actor/action和代码，员工正文显示原原因与实际文字动作；明确选择文件来源的动作给“设置 → 远程主机连接 → 工作区文件来源”，新建会话等动作保留原标签，不按错误码猜导航；不可用动作明确标记。技术原因officialReason不进正文，未提供按钮API时不编造可点击入口。
 
 未登录时两个模型均回复：**需要登录，请到设置 → 远程主机连接 点登录**。无L或缺正式能力时直接说明缺项，不让员工填写主机、用户、路径或密钥。
 
@@ -64,7 +68,7 @@ D19（0.8.1）：相邻正文增量合成连续文本块，工作区首次说明
 技术详情由 L 0.7.11 的唯一“远程主机连接”设置节展示，正文只放模型文本。命令目录保留完整描述；未知事件和工具输入输出保留字段、JSON类型及处理结果，未获准原文明确脱敏，数字用量可核对。没有 `remoteConversationDetails:1` 时明确提示“技术详情暂不可用”，本轮不发送模型请求。X 在官方当前 profile 的 `ai-workbench-remote-agent/diagnostics/` 保存私有诊断日志（目录700、文件600、落盘同步）；写入/归属/顺序/容量失败中止本轮，不自动重发、换代重投、过期或淘汰。结果未知时只读核对原事件完整回执，未找到仍保持未知。X本轮无新增设置/阈值；L的单事件容量和分页设置在L设置节可见。
 
 
-0.8.2 登录检查原交付需要 L `~0.7.11`（本统一版peer为`~0.7.18`），失败来源及固定分支保留到 L“登录前技术详情”（`loginDiagnostics:1`），员工正文保持原文。按 L 明确的本品牌 queued/checking/authorizing 状态订阅等待；不以全局checking猜测在途，不新增刷新、轮询、超时或重试。每轮ensureReady仍是合同规定的显式检查，L的新可信结果可以替代旧检查，较早返回不得覆盖它。
+0.8.2 登录检查原交付需要 L `~0.7.11`（本统一版peer为`~0.7.20`），失败来源及固定分支保留到 L“登录前技术详情”（`loginDiagnostics:1`），员工正文保持原文。按 L 明确的本品牌 queued/checking/authorizing 状态订阅等待；不以全局checking猜测在途，不新增刷新、轮询、超时或重试。每轮ensureReady仍是合同规定的显式检查，L的新可信结果可以替代旧检查，较早返回不得覆盖它。
 
 L安全规范的officialReason原串完整保留；旧/不支持格式明确记OFFICIAL_REASON_UNSUPPORTED与字节数/SHA，秘密原文不保存。L0.7.11的LOGIN_INSTANCE_MISMATCH记录通过observedLoginInstanceId与原始login.instanceId保存实际观测ID，事件及connection仍绑定当前可信ID/代次；L技术详情和X私有日志均保留真实双ID，不归一、不清空快照。复合未知官方原因以固定summary完整保存OFFICIAL_REASON_UNSUPPORTED及bytes/SHA，不交原文。X私有原快照先同步落盘，再追加L；ACK未知只读核实原事件，跨代不重写/重发。此版本的工程验证不替代leo员工路径复验，真实故障根因尚未证实。
 
@@ -76,7 +80,7 @@ D21（0.8.5）：两个品牌的官方模型菜单从 L 的 `modelCatalogTarget:
 
 每轮先核对目录代次和所选模型，再经 ACP 逐项配置模型及推理等级，收到完整配置确认后才发送输入。Claude 别名每轮须有精确的模型配置成功回执，并由同一员工主机、同一连接代际的目录唯一映射到具体型号。具体型号注明来自主机目录，会话未单独回报；旧恢复记录不作本轮证据。目录缺项、映射不唯一、回执不符或身份/代际变化时不发送输入。所选值、远端确认值及型号来源仅在恢复标识与技术详情保留，插件不向真实回复追加技术参数，确认配置不等于验证推理效果。连接/身份/目录变化清除旧确认；远端清理待定或结果未知时阻止派发，不自动清理重试或另开替代会话。Codex 单次模式当前不能确认此选择，会在发送前明确拒绝。新增设置 0；本轮工程证据、真实只读链路与产品未验项见 `docs/evidence/2026-10-22-X2-D21/`。
 
-0.8.5统一包原依赖L `~0.7.13`；当前0.8.15对齐L `~0.7.19`。D8模型目录双事件长期监听保留；同epoch的recovery提示/失败消息变化不触发执行状态失效，真实实例/epoch/phase/可信目标/登录变化仍失效。完整D9两品牌正文/状态/就绪门呈现按编排00:50允许的范围记下一版，本版不宣称已消费完成；L的connectionMessages.administratorAfterMs仍只由L管理，X新增设置0。
+0.8.5统一包原依赖L `~0.7.13`；0.8.16原对齐L `~0.7.19`；当前0.8.17对齐L `~0.7.20`。D8模型目录双事件长期监听保留；同epoch的recovery提示/失败消息变化不触发执行状态失效，真实实例/epoch/phase/可信目标/登录变化仍失效。完整D9两品牌正文/状态/就绪门呈现按编排00:50允许的范围记下一版，本版不宣称已消费完成；L的connectionMessages.administratorAfterMs仍只由L管理，X新增设置0。
 
 D18（0.8.6）：Codex 需要主机自有 adapter `2.2.2-aw.1` 的明确新建会话上下文政策，官方 CLI 仍为未改的0.160.1。系统/开发者要求仅在新建时生效；恢复时与初建摘要相同则正常恢复且省略新建专用字段，不声称恢复接口会更新指令。要求不同或清空时，在同一真实回复说明“会话要求已变化，已新建 Codex 会话继续处理，原会话仍保留。”，并新建远端承接公开对话，保留旧标识和查询记录；旧/非法初建摘要明确拒绝，不能猜测。
 
@@ -124,3 +128,5 @@ D20（0.8.8开发记录）：本地来源的Codex原生文件与命令通过固
 每次目录SSH保独立事件ID、品牌、UTC起止、耗时、PID、L实例/epoch/phase、严格L argv/目标/known_hosts/ProxyCommand、退出码/信号、完整脱敏stderr与原字节数/SHA256、stdout字节数/SHA及主机typed错误；不记录凭据或整份模型目录。日志在官方profile的 `ai-workbench-remote-agent/catalog-diagnostics/<eventId>-started.json` 与 `-closed.json`，700目录/600文件、fsync；无自动过期，最新两品牌在界面可展开，旧调用保留不可变历史。容量沿现有`acpMaxMessageBytes`，超限停止并标记stderrComplete=false，UTF-8替换另显式标记，未返回部分模型；保存失败明确显示仅内存，不冒称耐久。旧0811丢失的stderr无法还原。同品牌、instanceId、epoch只合并仍在进行的查询；完成后不缓存，身份/代际/可信目标改变即作废。调用方各持独立lease/取消与错误身份，一个取消不会取消其他等待者；全员取消才撤销该次查询，取消中的旧进程结束前同作用域新调用等待清理。登录检查的显示变化不会取消无需登录的host-user目录。此次没有增加超时、重试、SSH连接复用或产品设置；不等于255、Claude主机错误及N层根因已修复，也未进行leo GUI验收。
 
 0.8.14 不把空菜单、非穷举 picker、可选 UI category/label 或同值配置通知当作额外发送门槛；每轮仍要求可靠模型入口与 fresh exact setter ACK。本轮完成后的配置变化只记录 warning，保留真实回复与 finish，并明确未获单独的实际执行型号回报。同一身份、代际与可信目标的 needCode/诊断变化只记 info；真实身份、代际、目标或能力失效仍撤回。每次关闭/取消保留 caller、字段前后值和首次观测原因（不等于根因）。新增配置、阈值、超时、重试为 0。
+
+0.8.16 不新增 Config、默认值、阈值、超时或重试。首因可见、旧代不重投、实际选择与绑定一致属于不可关闭的正确性不变量。目录完成结果不用于后续请求缓存；活跃租约仅保留更新观测的选择有效性证据，释放即撤登记。断连/错代仍保留原详情信封及未确认状态，仅按旧合同读 receipt 核验。`unconfirmed-<eventId>.json` 私有记录追加是否尝试及失败阶段/固定码，不能当作 L 的 ACK；员工可见原因沿官方错误消息，无新增面板。

package/dist/acp.js

@@ -390,7 +390,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.15' },
+                protocolVersion: acp.PROTOCOL_VERSION, clientInfo: { name: '@ai-workbench/remote-agent', version: '0.8.17' },
                 clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false, session: { notices: {} }, ...(this.employeeMeta ? { _meta: { awEmployeeExecution: { version: 1 } } } : {}) },
             }, { cancellationSignal: signal }));
             this.hooks.broker?.acknowledge(acp.methods.agent.initialize);

package/dist/claude-local.js

@@ -31,6 +31,8 @@ export function createClaudeLocalProvider(options) {
             if (typeof local.getWorkspaceLocationState !== 'function')
                 throw failure('EMPLOYEE_CONTEXT_UNAVAILABLE');
             const workspace = await options.readWorkspace(request.sessionId), state = local.getWorkspaceLocationState(), matches = state.items.filter(row => row.workspaceId === workspace.workspaceId);
+            if (matches.length === 1 && matches[0].source === 'host')
+                return; // Host state/Need belongs to the host resolver, before local admission.
             if (matches.length !== 1 || state.phase !== 'ready' || state.instanceId !== connection.instanceId || state.epoch !== connection.epoch)
                 throw failure('EMPLOYEE_CONTEXT_CHANGED');
             const item = matches[0];

package/dist/close-diagnostics.d.ts

@@ -1,5 +1,4 @@
 import type { DetailObservation } from './conversation-details.ts';
-import { NeedError } from './remote.ts';
 export interface CloseChange {
     field: string;
     before: string | number | boolean | null;
@@ -18,11 +17,7 @@ export interface CloseCause {
     changes?: readonly CloseChange[];
 }
 export type CloseObserver = (cause: CloseCause) => void;
-/** Only typed codes, never exception messages, causes, stderr or RPC data. */
-export declare function closeCode(error: unknown, fallback?: string): string;
-/** Retain trusted typed codes through wrappers; never traverse error text or invoke getters. */
-export declare function closeErrorCodes(error: unknown, fallback?: string): string[];
-export declare function closeFailure(code: string, message: string, requires: string, codes: readonly string[]): NeedError;
+export { closeCode, closeErrorCodes, closeFailure, withFailureEvidence, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from './failure-evidence.ts';
 /** Assign order before abort/kill; persist through the existing asynchronous D19 outbox. */
 export declare class CloseDiagnostics {
     private sink;

package/dist/close-diagnostics.js

@@ -1,37 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { NeedError } from "./remote.js";
-/** Only typed codes, never exception messages, causes, stderr or RPC data. */
-export function closeCode(error, fallback = 'CLOSE_REASON_UNKNOWN') {
-    return error instanceof NeedError && /^[A-Z][A-Z0-9_]*$/.test(error.code) ? error.code : fallback;
-}
-/** Retain trusted typed codes through wrappers; never traverse error text or invoke getters. */
-export function closeErrorCodes(error, fallback = 'CLOSE_REASON_UNKNOWN') {
-    const queue = [error], seen = new Set(), codes = new Set();
-    while (queue.length) {
-        const next = queue.pop();
-        if (!(next instanceof NeedError || next instanceof AggregateError) || seen.has(next))
-            continue;
-        seen.add(next);
-        if (next instanceof NeedError) {
-            const code = Object.getOwnPropertyDescriptor(next, 'code');
-            if (code && 'value' in code && typeof code.value === 'string' && /^[A-Z][A-Z0-9_]*$/.test(code.value))
-                codes.add(code.value);
-        }
-        const cause = Object.getOwnPropertyDescriptor(next, 'cause');
-        if (cause && 'value' in cause)
-            queue.push(cause.value);
-        if (next instanceof AggregateError) {
-            const errors = Object.getOwnPropertyDescriptor(next, 'errors');
-            if (errors && 'value' in errors && Array.isArray(errors.value))
-                for (const child of errors.value)
-                    queue.push(child);
-        }
-    }
-    return codes.size ? [...codes] : [fallback];
-}
-export function closeFailure(code, message, requires, codes) {
-    return Object.assign(new NeedError(code, message, requires), { cause: new AggregateError([...new Set(codes)].map(value => new NeedError(value, '关闭收尾代码 ' + value, '按安全代码核对')), 'CLOSE_AND_DIAGNOSTIC_FAILURES') });
-}
+import { closeCode, closeErrorCodes, withFailureEvidence } from "./failure-evidence.js";
+export { closeCode, closeErrorCodes, closeFailure, withFailureEvidence, withFirstFailureEvidence, failureEvidenceSummary, primaryFailureCode } from "./failure-evidence.js";
 /** Assign order before abort/kill; persist through the existing asynchronous D19 outbox. */
 export class CloseDiagnostics {
     sink;
@@ -71,7 +41,7 @@ export class CloseDiagnostics {
         const payload = Object.freeze({ ...metadata, pendingOperations: Object.freeze([...this.pending.keys()]), closeId: this.id, ...this.parentId ? { parentCloseId: this.parentId } : {}, closeSequence: ++this.sequence, first, stage: this.stage, clock: 'client-monotonic', elapsedMs: performance.now() - this.started });
         this.firstValue ??= payload;
         try {
-            sink({ kind: 'session', severity: 'warning', code: first ? 'REMOTE_CLOSE_FIRST' : 'REMOTE_CLOSE_NEXT', summary: first ? '首次观察到关闭（不等同根因）' : '后续关闭或清理', payload });
+            sink({ kind: 'session', severity: 'warning', code: first ? 'REMOTE_CLOSE_FIRST' : 'REMOTE_CLOSE_NEXT', summary: cause.changedFields?.includes('selected-model') ? '最新可信目录已不再提供本轮所选型号，本轮已停止；请在模型菜单核对选择。' : first ? '首次观察到关闭（不等同根因）' : '后续关闭或清理', payload });
         }
         catch (error) {
             this.state.failure ??= { error };
@@ -97,7 +67,7 @@ export async function flushCloseDiagnostics(diagnostics, flush, primary) {
     }
     if (reporting.length) {
         const primaryCodes = primary ? closeErrorCodes(primary.error, 'REMOTE_CLEANUP_UNCONFIRMED') : [];
-        throw closeFailure('CONVERSATION_DETAILS_FAILED', '关闭诊断保存未完成；原关闭与清理结果需核对。', '首次关闭 ' + String(diagnostics.first?.reason ?? 'CLOSE_REASON_UNKNOWN') + '；清理 ' + (primaryCodes.join(',') || 'closed') + '；保存 ' + reporting.join(','), [...primaryCodes, ...reporting]);
+        throw withFailureEvidence(primary?.error ?? new NeedError(primaryCodes[0] ?? 'REMOTE_CLEANUP_UNCONFIRMED', '关闭收尾未确认', '核对实际结果'), reporting.map(code => new NeedError(code, '诊断保存未确认', '只读核对')), 'diagnostic', diagnostics.first?.reason);
     }
     if (primary)
         throw primary.error;

package/dist/connect-contract.d.ts

@@ -2,8 +2,8 @@ import type { ConnectNeed } from '@ai-workbench/connect/api';
 import type { ConnectTarget } from './provider.ts';
 import type { ContractInfo, Provider, WorkspaceUse, WorkspaceNoticeReceipt as LWorkspaceNoticeReceipt } from '@ai-workbench/connect/api';
 /** 正式L0.7公开类型；消费子集不表示已安装或已通过真实产品门。 */
-export type { WorkspaceNotice, SessionProjectTarget } from '@ai-workbench/connect/api';
-import type { SessionProjectTarget } from '@ai-workbench/connect/api';
+export type { WorkspaceNotice, SessionProjectTarget, HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
+import type { SessionProjectTarget, HostWorkspaceResolveContext, HostSessionProjectTarget } from '@ai-workbench/connect/api';
 export type LoginProvider = Provider;
 export type WorkspaceNoticeReceipt = Extract<LWorkspaceNoticeReceipt, {
     surface: 'provider';
@@ -17,11 +17,12 @@ export type ConnectResult<T> = {
         code: string;
         message: string;
         requires: string;
-    } & Pick<ConnectNeed, 'officialReason'>;
+    } & Partial<Pick<ConnectNeed, 'officialReason' | 'layer' | 'actor' | 'action' | 'lastSeen'>>;
 };
+export type SessionProjectResolution = SessionProjectTarget | HostSessionProjectTarget;
 export interface NativeWorkspaceApi {
     getContractInfo(): ContractInfo;
     ensureReady(provider: LoginProvider): Promise<ConnectResult<ConnectTarget>>;
-    resolveSessionProject(sessionId: string, use: WorkspaceUse): Promise<ConnectResult<SessionProjectTarget>>;
+    resolveSessionProject(sessionId: string, use: WorkspaceUse, location?: HostWorkspaceResolveContext): Promise<ConnectResult<SessionProjectResolution>>;
     acknowledgeWorkspaceNotice(receipt: WorkspaceNoticeReceipt): Promise<ConnectResult<void>>;
 }

package/dist/connect-need.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectNeed } from '@ai-workbench/connect/api';
+import { NeedError } from './remote.ts';
+type NeedInput = {
+    code: string;
+    message: string;
+    requires: string;
+} & Partial<Omit<ConnectNeed, 'code' | 'message' | 'requires'>>;
+/** Only the public L Need shape is employee wording; arbitrary errors stay diagnostic. */
+export declare function connectNeedError(value: NeedInput): NeedError;
+export declare function originalConnectNeed(error: unknown): Readonly<ConnectNeed> | undefined;
+export declare function connectNeedMessage(error: unknown): string | undefined;
+export {};

package/dist/connect-need.js

@@ -0,0 +1,34 @@
+import { NeedError } from "./remote.js";
+/** Only the public L Need shape is employee wording; arbitrary errors stay diagnostic. */
+export function connectNeedError(value) {
+    const error = new NeedError(value.code, value.message, value.requires);
+    if (typeof value.officialReason === 'string')
+        error.officialReason = value.officialReason;
+    if (typeof value.layer === 'string' && ['enrollment', 'network', 'ssh', 'auth', 'integration', 'settings', 'projects'].includes(value.layer) && typeof value.actor === 'string' && ['employee', 'administrator', 'ai-administrator', 'plugin'].includes(value.actor) && value.action && typeof value.action.id === 'string' && typeof value.action.label === 'string' && typeof value.action.available === 'boolean') {
+        error.connectNeed = Object.freeze({ code: value.code, layer: value.layer, message: value.message, requires: value.requires, actor: value.actor, action: Object.freeze({ id: value.action.id, label: value.action.label, available: value.action.available }), ...(typeof value.officialReason === 'string' ? { officialReason: value.officialReason } : {}), ...(typeof value.lastSeen === 'string' ? { lastSeen: value.lastSeen } : {}) });
+    }
+    return error;
+}
+export function originalConnectNeed(error) {
+    const queue = [error], seen = new Set();
+    while (queue.length) {
+        const item = queue.shift();
+        if (!item || typeof item !== 'object' || seen.has(item))
+            continue;
+        seen.add(item);
+        if (item instanceof NeedError && item.connectNeed)
+            return item.connectNeed;
+        if (item instanceof AggregateError)
+            queue.push(...item.errors);
+        if (item instanceof Error && item.cause !== undefined)
+            queue.push(item.cause);
+    }
+}
+export function connectNeedMessage(error) {
+    const need = originalConnectNeed(error);
+    if (!need)
+        return;
+    const location = need.action.id === 'select-workspace-location';
+    const action = location ? '设置 → 远程主机连接 → 工作区文件来源（' + need.action.label + '）' : need.action.label;
+    return need.message + (action ? '\n下一步' + (need.action.available ? '' : '（当前不可用）') + '：' + action + '。' : '');
+}

package/dist/conversation-details.js

@@ -345,7 +345,7 @@ function closeStructure(value) {
                     if (!change || typeof change !== 'object' || Array.isArray(change))
                         return opaqueStructure(change);
                     const field = change.field;
-                    const known = typeof field === 'string' && (/^(?:observer.close-sequence|executor.ended|transport.closed|transport.termination-requested|provider.ended|broker.ended|broker.attached|broker.lease-aborted|lease.aborted|lease.closed|mcp.ended|mcp.closing|mcp.poisoned|shell.settled|shell.stop-code|tools.aborted|tools.stop-code|acp.close-requested|adapter.turn-aborted|adapter.detached|adapter.shutting-down|workspace.binding-id|workspace.source|workspace.status|workspace.match-count|network.phase|catalog.api-replaced|catalog.capability|catalog.signature-sha256|connection.instance-id|connection.epoch|connection.phase|connection.need-code)$/.test(field) || /^catalog\.(?:codex|claude)\.(?:ok|error-code|instance-id|epoch|provider|target-sha256|metadata-sha256)$/.test(field));
+                    const known = typeof field === 'string' && (/^(?:observer.close-sequence|executor.ended|transport.closed|transport.termination-requested|provider.ended|broker.ended|broker.attached|broker.lease-aborted|lease.aborted|lease.closed|mcp.ended|mcp.closing|mcp.poisoned|shell.settled|shell.stop-code|tools.aborted|tools.stop-code|acp.close-requested|adapter.turn-aborted|adapter.detached|adapter.shutting-down|workspace.binding-id|workspace.source|workspace.status|workspace.match-count|network.phase|catalog.api-replaced|catalog.capability|catalog.signature-sha256|connection.instance-id|connection.epoch|connection.phase|connection.need-code)$/.test(field) || /^catalog\.(?:codex|claude)\.(?:ok|error-code|instance-id|epoch|provider|target-sha256|metadata-sha256|selected-model-valid)$/.test(field));
                     if (!known)
                         return opaqueStructure(change);
                     const scalar = (value) => value === null || typeof value === 'boolean' || typeof value === 'number' && Number.isFinite(value) || typeof value === 'string' && /^[a-zA-Z0-9_.:@-]+$/.test(value) ? value : opaqueStructure(value);

package/dist/employee-location.js

@@ -1,3 +1,4 @@
+import { connectNeedError } from "./connect-need.js";
 import { NeedError } from "./remote.js";
 import { isDeepStrictEqual } from 'node:util';
 const fail = (code) => new NeedError(code, '员工电脑的工作区或执行连接已变化，本轮没有继续执行。', '当前工作区绑定与员工端执行器');
@@ -29,7 +30,7 @@ export async function admitEmployeeLocation(options) {
         const result = await api.getLocalWorkspaceContext(request);
         signal?.throwIfAborted();
         if (!result.ok)
-            throw new NeedError(result.error.code, result.error.message, result.error.requires);
+            throw connectNeedError(result.error);
         const c = result.value;
         if (c.version !== 1 || c.source !== 'local' || c.instanceId !== connection.instanceId || c.epoch !== connection.epoch || c.workspaceId !== workspace.id || c.bindingId !== item.bindingId || !absolute(c.directory?.path) || c.directory.path !== workspace.path || !Number.isSafeInteger(c.directory.device) || !Number.isSafeInteger(c.directory.inode))
             throw fail('EMPLOYEE_CONTEXT_CHANGED');

package/dist/employee-provider.js

@@ -6,8 +6,9 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { connectNeedError } from "./connect-need.js";
 import { CODEX_EMPLOYEE_SCOPE_NOTICE } from "./employee-presentation.js";
-import { CloseDiagnostics, closeCode, closeErrorCodes } from "./close-diagnostics.js";
+import { CloseDiagnostics, withFailureEvidence, closeCode, closeErrorCodes } from "./close-diagnostics.js";
 import { createHash } from 'node:crypto';
 import { admitEmployeeLocation } from "./employee-location.js";
 import { EmployeeExecution } from "./employee-exec.js";
@@ -53,7 +54,7 @@ export async function acceptEmployeeUserTurn(get, employee, agent, api, request)
     stable();
     const context = await api.getLocalWorkspaceContext({ instanceId: connection.instanceId, epoch: connection.epoch, workspaceId: workspace.id, expectedBindingId: row.bindingId });
     if (!context.ok)
-        throw new NeedError(context.error.code, '无法核验本机工作区，本轮已停止。', '当前本机工作区');
+        throw connectNeedError(context.error);
     stable();
     const c = context.value, d = { ...c.directory };
     if (c.version !== 1 || c.source !== 'local' || c.instanceId !== connection.instanceId || c.epoch !== connection.epoch || c.workspaceId !== workspace.id || c.bindingId !== row.bindingId || !absolute(d?.path) || d.path !== workspace.path || ![d.device, d.inode].every(n => Number.isSafeInteger(n) && n >= 0))
@@ -63,7 +64,7 @@ export async function acceptEmployeeUserTurn(get, employee, agent, api, request)
         throw fail('LOCAL_USER_TURN_UNCONFIRMED');
     const response = await api.acceptLocalWorkspaceUserTurn({ instanceId: connection.instanceId, epoch: connection.epoch, sessionId: request.sessionId, provider: agent.loginProvider, purpose: 'user-turn', workspaceId: workspace.id, expectedBindingId: row.bindingId, expectedDirectory: { device: d.device, inode: d.inode }, expectedUserTurn: { ...expected } });
     if (!response.ok)
-        throw new NeedError(response.error.code, '本次员工输入或工作区无法核验，本轮已停止。', 'L 本地真实输入接纳');
+        throw connectNeedError(response.error);
     stable();
     const a = response.value;
     if (!a || a.version !== 1 || typeof a.acceptanceId !== 'string' || !a.acceptanceId.trim() || a.instanceId !== connection.instanceId || a.epoch !== connection.epoch || a.sessionId !== request.sessionId || a.provider !== agent.loginProvider || a.workspaceId !== workspace.id || a.bindingId !== row.bindingId || a.source !== 'local' || a.directory?.path !== d.path || a.directory?.device !== d.device || a.directory?.inode !== d.inode || a.userTurn?.turn !== expected.turn || a.userTurn?.userMessageId !== expected.userMessageId || ![a.userTurn?.startSequence, a.userTurn?.userMessageSequence].every(n => Number.isSafeInteger(n) && n >= 0) || a.userTurn.userMessageSequence <= a.userTurn.startSequence)
@@ -86,7 +87,7 @@ export async function validateEmployeeUserTurn(get, employee, api, request, conn
     const c = await api.getLocalWorkspaceContext({ instanceId: a.instanceId, epoch: a.epoch, workspaceId: a.workspaceId, expectedBindingId: a.bindingId });
     stable();
     if (!c.ok)
-        throw new NeedError(c.error.code, '无法核验本机工作区，本轮已停止。', '当前本机工作区');
+        throw connectNeedError(c.error);
     if (c.value.version !== 1 || c.value.source !== 'local' || c.value.instanceId !== a.instanceId || c.value.epoch !== a.epoch || c.value.workspaceId !== a.workspaceId || c.value.bindingId !== a.bindingId || c.value.directory.path !== a.directory.path || c.value.directory.device !== a.directory.device || c.value.directory.inode !== a.directory.inode)
         throw fail('EMPLOYEE_CONTEXT_CHANGED');
     const turn = employee.currentUserTurn(request);
@@ -336,13 +337,21 @@ export function createEmployeeProvider(get, options, agent) {
             return runtime;
         }
         catch (error) {
-            details?.record({ kind: 'need', severity: 'action-required', code: errorCode(error), summary: asNeed(error).message, payload: { result: 'UNKNOWN' } });
+            const reporting = [];
+            try {
+                details?.record({ kind: 'need', severity: 'action-required', code: errorCode(error), summary: asNeed(error).message, payload: { result: 'UNKNOWN' } });
+            }
+            catch (failure) {
+                reporting.push(failure);
+            }
             try {
                 await details?.flush();
             }
-            catch {
-                throw fail('CONVERSATION_DETAILS_FAILED');
+            catch (failure) {
+                reporting.push(failure);
             }
+            if (reporting.length)
+                throw withFailureEvidence(error, reporting, 'diagnostic', closeDiagnostics?.first?.reason);
             throw error;
         }
     };

package/dist/failure-evidence.d.ts

@@ -0,0 +1,12 @@
+import { NeedError } from './remote.ts';
+/** Only typed codes, never exception messages, causes, stderr or RPC data. */
+export declare function closeCode(error: unknown, fallback?: string): string;
+/** Retain trusted typed codes through wrappers; never traverse error text or invoke getters. */
+export declare function closeErrorCodes(error: unknown, fallback?: string): string[];
+export declare function closeFailure(code: string, message: string, requires: string, codes: readonly string[]): NeedError;
+/** Saving succeeded: retain the original trusted error type, code and presentation. */
+export declare function withFirstFailureEvidence<T>(primary: T, firstReason: unknown, primaryCode: string): T;
+/** Preserve causal roles without copying arbitrary exception text into employee output. */
+export declare function withFailureEvidence(primary: unknown, secondary: readonly unknown[], kind: 'diagnostic' | 'cleanup', firstReason?: unknown, primaryCode?: string): NeedError;
+export declare function primaryFailureCode(error: unknown, fallback: string): string;
+export declare function failureEvidenceSummary(error: unknown): string;

package/dist/failure-evidence.js

@@ -0,0 +1,83 @@
+import { NeedError } from "./remote.js";
+/** Only typed codes, never exception messages, causes, stderr or RPC data. */
+export function closeCode(error, fallback = 'CLOSE_REASON_UNKNOWN') {
+    return error instanceof NeedError && /^[A-Z][A-Z0-9_]*$/.test(error.code) ? error.code : fallback;
+}
+/** Retain trusted typed codes through wrappers; never traverse error text or invoke getters. */
+export function closeErrorCodes(error, fallback = 'CLOSE_REASON_UNKNOWN') {
+    const queue = [error], seen = new Set(), codes = new Set();
+    while (queue.length) {
+        const next = queue.pop();
+        if (!(next instanceof NeedError || next instanceof AggregateError) || seen.has(next))
+            continue;
+        seen.add(next);
+        if (next instanceof NeedError) {
+            const code = Object.getOwnPropertyDescriptor(next, 'code');
+            if (code && 'value' in code && typeof code.value === 'string' && /^[A-Z][A-Z0-9_]*$/.test(code.value))
+                codes.add(code.value);
+        }
+        const cause = Object.getOwnPropertyDescriptor(next, 'cause');
+        if (cause && 'value' in cause)
+            queue.push(cause.value);
+        if (next instanceof AggregateError) {
+            const errors = Object.getOwnPropertyDescriptor(next, 'errors');
+            if (errors && 'value' in errors && Array.isArray(errors.value))
+                for (const child of errors.value)
+                    queue.push(child);
+        }
+    }
+    return codes.size ? [...codes] : [fallback];
+}
+export function closeFailure(code, message, requires, codes) {
+    return Object.assign(new NeedError(code, message, requires), { cause: new AggregateError([...new Set(codes)].map(value => new NeedError(value, '关闭收尾代码 ' + value, '按安全代码核对')), 'CLOSE_AND_DIAGNOSTIC_FAILURES') });
+}
+const evidence = new WeakMap();
+const safeCode = (code) => typeof code === 'string' && /^[A-Z][A-Z0-9_]*$/.test(code);
+function retainedEvidence(error) {
+    const queue = [error], seen = new Set();
+    while (queue.length) {
+        const current = queue.shift();
+        if (current && typeof current === 'object') {
+            const known = evidence.get(current);
+            if (known)
+                return known;
+        }
+        if (!(current instanceof NeedError || current instanceof AggregateError) || seen.has(current))
+            continue;
+        seen.add(current);
+        const cause = Object.getOwnPropertyDescriptor(current, 'cause');
+        if (cause && 'value' in cause)
+            queue.push(cause.value);
+        const children = Object.getOwnPropertyDescriptor(current, 'errors');
+        if (children && 'value' in children && Array.isArray(children.value))
+            queue.push(...children.value);
+    }
+    return undefined;
+}
+/** Saving succeeded: retain the original trusted error type, code and presentation. */
+export function withFirstFailureEvidence(primary, firstReason, primaryCode) {
+    if (primary && typeof primary === 'object' && safeCode(firstReason) && safeCode(primaryCode)) {
+        const previous = retainedEvidence(primary);
+        evidence.set(primary, Object.freeze({ first: previous?.first ?? firstReason, original: previous?.original ?? Object.freeze([primaryCode]), diagnostic: previous?.diagnostic ?? Object.freeze([]), cleanup: previous?.cleanup ?? Object.freeze([]) }));
+    }
+    return primary;
+}
+/** Preserve causal roles without copying arbitrary exception text into employee output. */
+export function withFailureEvidence(primary, secondary, kind, firstReason, primaryCode) {
+    const previous = retainedEvidence(primary), first = previous?.first ?? (safeCode(firstReason) ? firstReason : undefined);
+    const original = previous?.original ?? (safeCode(primaryCode) ? [primaryCode] : closeErrorCodes(primary, 'TURN_FAILED'));
+    const secondaryFacts = secondary.map(retainedEvidence), added = [...new Set(secondary.flatMap((error, index) => secondaryFacts[index] ? secondaryFacts[index].original.filter(code => !original.includes(code)) : closeErrorCodes(error, kind === 'diagnostic' ? 'DIAGNOSTIC_WRITE_FAILED' : 'REMOTE_CLEANUP_UNCONFIRMED')))];
+    const facts = Object.freeze({ ...(first ? { first } : {}), original: Object.freeze(original), diagnostic: Object.freeze([...new Set([...(previous?.diagnostic ?? []), ...secondaryFacts.flatMap(f => f?.diagnostic ?? []), ...(kind === 'diagnostic' ? added : [])])]), cleanup: Object.freeze([...new Set([...(previous?.cleanup ?? []), ...secondaryFacts.flatMap(f => f?.cleanup ?? []), ...(kind === 'cleanup' ? added : [])])]) });
+    const code = kind === 'cleanup' ? 'REMOTE_CLEANUP_UNCONFIRMED' : !secondary.length ? primary instanceof NeedError ? primary.code : safeCode(primaryCode) ? primaryCode : 'TURN_FAILED' : primary instanceof NeedError && facts.diagnostic.length > 0 && facts.diagnostic.every(code => code === primary.code) && !facts.cleanup.length && !previous ? primary.code : 'CONVERSATION_DETAILS_FAILED';
+    const failure = Object.assign(new NeedError(code, '本轮已停止；运行原因与诊断或清理结果分别保留。', '核对原始原因及未确认的保存/清理结果'), { cause: new AggregateError([primary, ...(safeCode(primaryCode) && !(primary instanceof NeedError) ? [new NeedError(primaryCode, '运行错误代码', '可信调用点提供的固定代码')] : []), ...secondary, ...(first ? [new NeedError(first, '首次观察关闭代码', '不是已证明根因')] : [])], 'TURN_FAILURE_EVIDENCE') });
+    evidence.set(failure, facts);
+    failure.requires = '原错误代码 ' + facts.original.join('、') + (facts.diagnostic.length ? '；诊断错误代码 ' + facts.diagnostic.join('、') : '') + (facts.first ? '；首次观察关闭 ' + facts.first : '') + (facts.cleanup.length ? '；清理错误代码 ' + facts.cleanup.join('、') : '');
+    return failure;
+}
+export function primaryFailureCode(error, fallback) { return retainedEvidence(error)?.original[0] ?? fallback; }
+export function failureEvidenceSummary(error) {
+    const facts = retainedEvidence(error);
+    if (!facts)
+        return '';
+    return '技术详情：' + [...(facts.first ? ['首次观察关闭 ' + facts.first] : []), '运行原因 ' + facts.original.join('、'), ...(facts.diagnostic.length ? ['详情保存未确认 ' + facts.diagnostic.join('、')] : []), ...(facts.cleanup.length ? ['清理未确认 ' + facts.cleanup.join('、')] : [])].join('；');
+}

package/dist/host-workspace.d.ts

@@ -0,0 +1,13 @@
+import type { ConnectApi, ConnectTarget, ConnectionState, RuntimeRequest, Runtime } from './provider.ts';
+import type { NativeWorkspaceApi, HostSessionProjectTarget, LoginProvider } from './connect-contract.ts';
+import type { WorkspaceSourceOptions } from './workspace-source.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: WorkspaceSourceOptions['workspace'] | undefined, provider: LoginProvider): Promise<HostWorkspaceGuard | undefined>;

package/dist/host-workspace.js

@@ -0,0 +1,110 @@
+import { basename } from 'node:path/posix';
+import { awaitL, sameTarget, unwrap } from "./provider.js";
+import { connectNeedError } from "./connect-need.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关系');
+        return;
+    }
+    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)
+        return;
+    if (selected.source !== 'host') {
+        if (selected.source !== null && !['local', 'legacy-host'].includes(selected.source))
+            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)
+                        revoke(error);
+                    throw error;
+                }
+            }
+        };
+    }
+    catch (error) {
+        dispose();
+        throw error;
+    }
+}