release-skill 0.9.1 → 0.9.4

package/skills-src/release-marketplace/SKILL.md

@@ -44,7 +44,7 @@ byte、platform manifest 是核心 gate，由 workspace 自己的生成器与
 
 ## 正向执行路径
 
-1. 运行 `release-skill route --root <path> --json` 获取 diff 分类
+1. 运行 `release-skill route --root <path> [--target-version <ver>] --json` 获取 diff 分类；已知目标版本时显式传入，route 只是工作流建议
 2. 若推荐 `workflowKind === 'marketplace-only'`，则使用本技能
 3. 执行步骤②：手动审查并更新 `plugins.mjs`（唯一 truth source）
 4. 执行步骤③：调用 workspace 自己的生成器再生成 `public-snapshot/`
@@ -59,6 +59,8 @@ byte、platform manifest 是核心 gate，由 workspace 自己的生成器与
 # Step 1: Diff classification confirmation (marketplace-only)
 node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" route \
   --root <workspace-root> --json
+node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" route \
+  --root <workspace-root> --target-version <version> --json
 
 # Step 2: Manual review and update plugins.mjs
 # Human-in-the-loop: entry is the sole truth source

package/skills-src/release-prepare/SKILL.md

@@ -13,6 +13,10 @@ description: Freeze an immutable release plan with local configuration, document
 
 运行项目构建/测试 hook，生成公开快照并扫描泄漏，冻结不可变发布计划。prepare 自身不调用发布 adapter，但会执行用户配置的 hook。
 
+0.9.4 候选允许多发布单元项目在冻结前显式选择本轮范围。`--unit <id>` 可以重复传入；未传时仍选择全部单元。显式选择只跳过延期单元的单元级工作，完整配置校验、生成物新鲜度和顶层 Hook 仍全部执行。计划冻结后以 `plan.units` 为唯一范围权威，publish、reconcile、verify 和 distribute 不接受单元选择。
+
+0.9.3 引入的 Hook cache v2 继续只复用有完整身份和输入证据的成功 Hook 结果。裸 PATH、PATHEXT、Windows、TTL、损坏记录或 Foundation 观察不可用时，缓存保持失败关闭，Hook 仍按完整路径冷执行；该机制不改变 prepare 的计划、批准和发布权威。
+
 **Hook 授权契约（配置时刻即授权，FM-16 处置 A）**: hook 是任意本地进程——在 `.release-skill/project.yaml` 中配置 hook 命令即完成授权，构成「配置时刻即授权」的显式契约。hook 不提供沙箱、无文件系统/网络隔离、触发前无确认点，命令调用本身即授权执行已配置的 hook 和 gate，不再设置额外人工授权环节；hook 可能产生项目目录外的副作用或远端写入，配置者须对其内容负责。旧参数 `--acknowledge-hook-side-effects` 和 `--acknowledge-gate-side-effects` 仍可解析，但只作为无效果的兼容输入，不能改变授权或执行语义。恢复「触发前强制确认门」属于后续加固项（属设计变更，需随新版本引入），当前版本不提供该确认门。
 
 **阶段通过规则**: 本阶段的通过只能由 CLI exit code 0 和结构化状态码 `PREPARED` 确认。Agent 无权自行宣布计划冻结成功。
@@ -23,11 +27,13 @@ description: Freeze an immutable release plan with local configuration, document
 
 **发布文档新鲜度门**: 配置了 `releaseDocuments` 的单元在 hook 授权门前先执行同一只读规划器：`clean` 继续；`changes` 抛 `RELEASE_DOCS_STALE`，详情列出相对路径、语种、`refreshDigest` 和精确演练/写入参数数组。prepare 只检查、不写工作树。正式 prepare 前先运行只读演练；有变化时向用户展示文件/语种/版本/`refreshDigest`，只有在用户明确授权"本地发布文档写入"后，才执行带 `--write --confirm-refresh <refreshDigest> --ack-local-document-write` 三项绑定的写入，随后运行聚焦校验，要求维护者审阅并提交刷新结果，再重新 prepare。该授权不扩展为 hook、提交、push 或 publish 授权。
 
+**显式发布范围**: 只有用户已经指出本轮要发布哪些单元时，才把这些 ID 逐个传给 `--unit`。release-skill 不根据失败自动排除单元。选择命中 `publicSourceAuthorityReceipt` 的 coordinator 或 subject 时，必须包含收据声明的完整单元闭包；缺少单元时按命令返回的精确 argv 重新选择，不自动扩选。成功后展示 `releaseScope.selectedUnitIds`、`releaseScope.deferredUnitIds` 和批准摘要。延期仅表示没有进入本轮计划，不表示通过或失败。
+
 ## 正向执行路径
 
 1. 使用插件根相对路径运行 CLI：`CLI="node ${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs"`
 2. 配置含 `releaseDocuments` 时，先运行只读演练 `${CLI} docs refresh --unit <id> --json`；`status: "changes"` 时展示逐文件路径/语种/版本/`refreshDigest`，取得"本地发布文档写入"明确授权后才执行 `nextCommand.argv` 写入，审阅并提交刷新结果后再继续；`status: "clean"` 时直接进入 prepare
-3. 运行 `${CLI} prepare --root <path> --offline --json`
+3. 运行 `${CLI} prepare --root <path> --offline --json`；用户已明确选择范围时，为每个单元追加一个 `--unit <id>`
 4. 检查 exit code 0，读取 JSON 返回的 immutable `planPath=plans/<planDigest>.json`，再从该文件读取 `status`、`units`、`externalActions`
 5. 向用户展示可读的 `approvalSummary`：版本、公开仓库、分支策略、branch/tag、npm 与 GitHub Release 目标、全部外部动作、例外，以及需要独立 checkpoint 批准的 postPublish hook。`planDigest` 仅作为内部绑定字段，不要求用户复制或确认。后续 approve/publish 只能使用该 immutable planPath，等待确认后再 approve。计划批准不包含受限 postPublish hook 的 checkpoint 批准
 
@@ -62,6 +68,9 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" docs refresh --unit <id> --js
 node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" docs refresh --unit <id> \
   --write --confirm-refresh <refreshDigest> --ack-local-document-write --json
 node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" prepare --root <path> --offline --json
+# 显式选择发布范围；未传 --unit 时仍准备全部配置单元
+node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" prepare --root <path> --offline \
+  --unit <unit-a> --unit <unit-b> --json
 # 生产 happy end：bound 基线必须 online；远端目标唯一性仍由 publish 全局预检
 node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" prepare --root <path> --online --production --json
 ```
@@ -79,11 +88,12 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill.mjs" prepare --root <path> --onlin
 | GATE_FAILED (bound + offline) | 改用 `--online --production`，不得把 unobserved-offline plan 交给 publish |
 | GATE_FAILED (前序基线漂移) | 先取得并比较实际远端内容；人工选择 merge/adopt/reject。merge/adopt 都必须把接受内容落回 human-owned 权威源，并把 `previousPublicBaseline` 更新为接受状态的精确 repo/ref/commit 后重新 online production prepare；reject 停止调查，禁止改 `mode: none` 绕过 |
 | GATE_FAILED (`npm-entry-closure`) | 修复打包内容或入口声明后重新 prepare；不得用 `requiredPublicFiles`/`smokeBin` 缺省绕过 |
+| GATE_FAILED（发布范围依赖闭包不完整） | 按详情补齐 `publicSourceAuthorityReceipt` 声明涉及的 coordinator 和全部 subjects，再重新 prepare；不得自动扩选或忽略收据 |
 | GATE_FAILED (其他) | 修复门失败原因后重试；以 CLI exit code 为准 |
 | RELEASE_DOCS_STALE | 文档相对说明源已陈旧；按详情运行只读演练，展示文件/语种/版本/摘要，经用户授权“本地发布文档写入”后执行写入，审阅提交再重新 prepare |
 | RELEASE_DOCS_INVALID / TRANSLATION_MISSING / CONFLICT / REFRESH_STALE | 修复配置/说明源/目标或重新演练取得新 `refreshDigest`；不得扩大写入范围绕过 |
 | SECRET_DETECTED | 移除密钥并更新 allowlist |
-| CONFIG_INVALID | 检查 version.source 和 package.json |
+| CONFIG_INVALID | 检查 version.source、package.json，以及 `--unit` 是否为空、重复或不在 `releaseUnits[]` 中 |
 
 重试时只保留最新结构化错误码和失败门，不沿用早期猜测；重跑确定性命令获得新证据。
 

package/skills-src/release-publish/SKILL.md

@@ -21,16 +21,23 @@ description: "从已批准的生产计划发布冻结 Git branch/tag、npm tarba
 
 ## 前置条件：工作流选择
 
-在运行 `release-publish` 之前，必须先完成快速入门决策路由（§4.3 Workflow Profile Support）：
-
-1. 使用 `release-skill route --root <path> --json` 确定变更类型
-2. 根据推荐的 `workflowKind` 选择对应路径：
-   - `docs-only` → 先执行 `release-docs` 完整流程
-   - `config-only` → 先执行 `release-config`，仅在 public surface 变化时进入 publish
-   - `marketplace-only` → 先执行 `release-marketplace`，然后由 workspace exclusive skill 接管
-   - `full-happy-end` → 直接进入标准完整流程：`prepare → approve → publish → verify`
-   - `reconcile` → 先执行 `release-reconcile` 恢复 PARTIAL 状态
-   - `help` → 无变更，无需 publish
+调用方持有合法、未过期且绑定当前 production plan 的 approval record 时，
+`release-publish` 直接执行自身的计划、批准、冻结制品身份和远端预检。`route` 只提供
+工作流建议，不是已批准 production plan 的授权门。
+
+尚未形成计划时，可以先使用 `release-skill route --root <path> --json` 确定变更类型。
+已知目标版本时一并传入 `--target-version <version>`，使恢复建议只读取与该目标绑定的
+完整运行血缘。未传目标时，route 仍按 diff/baseline 选择工作流；历史 diagnostics 只作
+报告，不得覆盖当前建议。
+
+根据推荐的 `workflowKind` 选择对应路径：
+
+- `docs-only` → 先执行 `release-docs` 完整流程
+- `config-only` → 先执行 `release-config`，仅在 public surface 变化时进入 publish
+- `marketplace-only` → 先执行 `release-marketplace`，然后由 workspace exclusive skill 接管
+- `full-happy-end` → 直接进入标准完整流程：`prepare → approve → publish → verify`
+- `reconcile` → 先执行 `release-reconcile` 恢复 PARTIAL 状态
+- `help` → 无变更，无需 publish
 
 **注意**: `release-publish` 是标准工作流中的第⑦步，必须在以下步骤之后：
 - 步骤⑤: `release-prepare` (或轻量级 prepare)

package/skills-src/release-verify/SKILL.md

@@ -29,6 +29,8 @@ verify 只接受 `PUBLISHED` 状态的源 run；`VERIFIED` 是终态，不会再
 
 验证远端所有自动化 action 的实际状态与冻结计划一致。执行精确 `<package>@<version>` npm 安装到隔离目录，验证包名、版本、静态入口闭包，并在配置时验证 bin 路径安全和 CLI 烟雾输出。对 Claude/Codex marketplace distribution 执行全新隔离消费者安装验证。新计划中的 Kimi/CodeBuddy 安装只返回 `manualFollowUps`，明确标记 `verifiedBySystem: false`，不阻塞 `VERIFIED`；缺少该策略字段的旧冻结计划继续走历史 attestation 兼容路径。
 
+0.9.3 的稳定隔离安装树记录只消费宿主命令退出后的隔离树观察：宿主附加 link 记录自身但不跟随，声明载荷 symlink 失败关闭，legacy 全树语义保持不变。该观察属于安装树事实，不替代远端状态、发布计划或 `VERIFIED` 判断。
+
 **attestation 证明力边界**: `attest` 命令记录的旧计划兼容人工证明（`humanConfirmed: true` → `PASSED_MANUAL`）是本地自声明收据，不是签名见证：`--actor` 仅做非空字符串校验，无外部签名或身份核验，任何能运行 CLI 的进程都能自称任意 actor；伪造收据需写 `.release-skill` authority 目录，与直接改写收据文件属同一信任边界。因此旧兼容路径的人工证明只用于旧冻结计划收尾，不构成独立可审计的人工见证。新计划的 Kimi/CodeBuddy 安装一律走 `manualFollowUps`（`verifiedBySystem: false`），不参与 `VERIFIED` 终态判定。
 
 **阶段通过规则**: 只有 CLI exit code 0 和结构化状态码 `VERIFIED` 才是完整终态。

package/src/commands/post-release-local.mjs

@@ -35,6 +35,16 @@ const SAFE_ENV_KEYS = Object.freeze([
   'SSL_CERT_FILE', 'SSL_CERT_DIR', 'NODE_EXTRA_CA_CERTS',
   'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'KIMI_CONFIG_DIR',
 ]);
+const CODEBUDDY_PLUGIN_LIST_ARGS = Object.freeze(['plugin', 'list', '--json']);
+const CODEBUDDY_MARKETPLACE_LIST_ARGS = Object.freeze(['plugin', 'marketplace', 'list']);
+
+function attachFoundationFailure(error, { envelope, stdout }) {
+  Object.defineProperties(error, {
+    foundationEnvelope: { value: envelope, enumerable: false },
+    foundationStdout: { value: stdout, enumerable: false },
+  });
+  return error;
+}
 
 function actionTarget(plan, action, host) {
   const parameters = action.parameters ?? {};
@@ -259,7 +269,7 @@ async function defaultRun(command, args, options = {}) {
         watchdogReason: envelope.watchdogReason,
         ...(envelope.evidence?.spawnError ? { spawnError: envelope.evidence.spawnError } : {}),
       };
-      throw error;
+      throw attachFoundationFailure(error, { envelope, stdout });
     }
     return { stdout, stderr };
   }, { prefix: 'release-skill-host-command-' });
@@ -303,6 +313,96 @@ function parseJson(stdout, label) {
   }
 }
 
+function foundationEnvelopeFromError(error) {
+  return error?.foundationEnvelope ?? null;
+}
+
+function foundationStdoutFromError(error) {
+  return error?.foundationStdout ?? null;
+}
+
+function isCodeBuddyResidualEnvelope(error) {
+  const envelope = foundationEnvelopeFromError(error);
+  const evidence = envelope?.evidence;
+  const signals = evidence?.signalSequence;
+  const signal = signals?.[0];
+  return envelope?.ok === false
+    && envelope.exitStatus === 124
+    && envelope.processStatus === 'TERMINATED'
+    && envelope.terminationReason === 'child_exit'
+    && envelope.watchdogReason === 'residual_process_group'
+    && evidence?.childExitCode === 0
+    && (evidence.childSignal === null || evidence.childSignal === undefined)
+    && evidence.residualGroupCleanupCompleted === true
+    && evidence.forcedKill === false
+    && evidence.outputLimitExceeded === null
+    && Array.isArray(signals)
+    && signals.length === 1
+    && signal?.signal === 'SIGTERM'
+    && signal.requestedMode === 'process_group'
+    && signal.successfulMode === 'process_group';
+}
+
+function isCodeBuddyReadCommand(target, command, args) {
+  return target.host === 'codebuddy'
+    && (command === 'codebuddy' || command === 'cbc' || command === CODEBUDDY_MACOS_PATH)
+    && Array.isArray(args)
+    && (
+      args.every((value, index) => value === CODEBUDDY_PLUGIN_LIST_ARGS[index])
+      && args.length === CODEBUDDY_PLUGIN_LIST_ARGS.length
+      || args.every((value, index) => value === CODEBUDDY_MARKETPLACE_LIST_ARGS[index])
+      && args.length === CODEBUDDY_MARKETPLACE_LIST_ARGS.length
+    );
+}
+
+function isCodeBuddyWriteCommand(target, command, args, kind) {
+  if (target.host !== 'codebuddy' || !['codebuddy', 'cbc', CODEBUDDY_MACOS_PATH].includes(command)) return false;
+  const expected = kind === 'marketplace-update'
+    ? ['plugin', 'marketplace', 'update', target.marketplace]
+    : ['plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user'];
+  return Array.isArray(args) && args.length === expected.length && args.every((value, index) => value === expected[index]);
+}
+
+async function runCodeBuddyRead(target, command, args, label, env, run) {
+  try {
+    return { output: await run(command, [...args], { env }), recovered: false };
+  } catch (error) {
+    if (!isCodeBuddyReadCommand(target, command, args) || !isCodeBuddyResidualEnvelope(error)) throw error;
+    const residualStdout = foundationStdoutFromError(error);
+    if (typeof residualStdout !== 'string') throw error;
+    parseJson(residualStdout, label);
+    return {
+      output: { stdout: residualStdout, stderr: '' },
+      recovered: true,
+    };
+  }
+}
+
+function exactCodeBuddyMarketplaceObservation(target, stdout) {
+  const parsed = parseJson(stdout, `${target.host} marketplace list`);
+  if (!Array.isArray(parsed)) throw new Error(`${target.host} marketplace list did not return an array`);
+  const matches = parsed.filter((entry) => entry?.name === target.marketplace);
+  if (matches.length !== 1) {
+    throw new Error(`${target.host} marketplace list did not contain exactly one ${target.marketplace}`);
+  }
+  if (matches[0].type !== 'git') {
+    throw new Error(`${target.host} marketplace ${target.marketplace} is not a git marketplace`);
+  }
+  return { installed: true, exact: true, found: matches[0] };
+}
+
+async function observeCodeBuddyMarketplaceAfterResidual(target, command, env, run) {
+  const observed = await runCodeBuddyRead(
+    target,
+    command,
+    CODEBUDDY_MARKETPLACE_LIST_ARGS,
+    `${target.host} marketplace list`,
+    env,
+    run,
+  );
+  return exactCodeBuddyMarketplaceObservation(target, observed.output.stdout);
+}
+
 function exactPluginObservation(target, stdout) {
   const selector = `${target.plugin}@${target.marketplace}`;
   const parsed = parseJson(stdout, `${target.host} plugin list`);
@@ -433,7 +533,10 @@ async function runStructuredUpdate(target, detected, run, {
 }) {
   if (target.host === 'codebuddy' || target.host === 'workbuddy') {
     const env = hostEnvironment(target.host);
-    const listed = await run(detected.command, ['plugin', 'list', '--json'], { env });
+    const listedObservation = target.host === 'codebuddy'
+      ? await runCodeBuddyRead(target, detected.command, CODEBUDDY_PLUGIN_LIST_ARGS, `${target.host} plugin list`, env, run)
+      : { output: await run(detected.command, [...CODEBUDDY_PLUGIN_LIST_ARGS], { env }), recovered: false };
+    const listed = listedObservation.output;
     const observed = exactPluginObservation(target, listed.stdout);
     if (
       target.sourceForm !== 'bundled-family'
@@ -445,7 +548,13 @@ async function runStructuredUpdate(target, detected, run, {
         reason: `${target.host} source identity is not eligible for a frozen bundled-family update`,
       };
     }
-    if (observed.exact) return { status: 'ALREADY_CURRENT', version: target.version };
+    if (observed.exact) {
+      return {
+        status: 'ALREADY_CURRENT',
+        version: target.version,
+        ...(listedObservation.recovered ? { residualRecovery: true } : {}),
+      };
+    }
     if (!observed.installed) {
       return {
         status: 'MANUAL_REQUIRED',
@@ -471,14 +580,51 @@ async function runStructuredUpdate(target, detected, run, {
         reason: `${target.host} frozen tag and mutable ref do not both resolve to ${target.pluginCommit}`,
       };
     }
-    await run(detected.command, ['plugin', 'marketplace', 'update', target.marketplace], { env });
-    await run(detected.command, [
-      'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
-    ], { env });
-    const afterList = await run(detected.command, ['plugin', 'list', '--json'], { env });
-    const after = exactPluginObservation(target, afterList.stdout);
+    let marketplaceRecovered = false;
+    try {
+      await run(detected.command, ['plugin', 'marketplace', 'update', target.marketplace], { env });
+    } catch (error) {
+      if (!isCodeBuddyWriteCommand(target, detected.command, ['plugin', 'marketplace', 'update', target.marketplace], 'marketplace-update')
+        || !isCodeBuddyResidualEnvelope(error)) throw error;
+      await observeCodeBuddyMarketplaceAfterResidual(target, detected.command, env, run);
+      marketplaceRecovered = true;
+    }
+    let after;
+    let pluginRecovered = false;
+    try {
+      await run(detected.command, [
+        'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
+      ], { env });
+    } catch (error) {
+      if (!isCodeBuddyWriteCommand(target, detected.command, [
+        'plugin', 'update', `${target.plugin}@${target.marketplace}`, '--scope', 'user',
+      ], 'plugin-update') || !isCodeBuddyResidualEnvelope(error)) throw error;
+      const afterList = await runCodeBuddyRead(
+        target,
+        detected.command,
+        CODEBUDDY_PLUGIN_LIST_ARGS,
+        `${target.host} plugin list`,
+        env,
+        run,
+      );
+      after = exactPluginObservation(target, afterList.output.stdout);
+      pluginRecovered = true;
+    }
+    if (!pluginRecovered) {
+      const afterList = target.host === 'codebuddy'
+        ? await runCodeBuddyRead(target, detected.command, CODEBUDDY_PLUGIN_LIST_ARGS, `${target.host} plugin list`, env, run)
+        : { output: await run(detected.command, [...CODEBUDDY_PLUGIN_LIST_ARGS], { env }), recovered: false };
+      after = exactPluginObservation(target, afterList.output.stdout);
+    }
     if (!after.exact) throw new Error(`${target.host} did not update to the frozen plugin identity`);
-    return { status: 'UPDATED', version: target.version, restartRequired: true };
+    return {
+      status: 'UPDATED',
+      version: target.version,
+      restartRequired: true,
+      ...(marketplaceRecovered || listedObservation.recovered || pluginRecovered
+        ? { residualRecovery: true }
+        : {}),
+    };
   }
 
   const command = detected.command;
@@ -566,9 +712,9 @@ expect {
       timeout { exit 95 }
       eof { exit 96 }
     }
-    expect -re {> $}
+    expect -re $promptPattern
   }
-  -re {> $} {}
+  -re $promptPattern {}
   timeout { exit 93 }
   eof { exit 94 }
 }
@@ -581,8 +727,9 @@ foreach variable {RELEASE_SKILL_KIMI_COMMAND RELEASE_SKILL_KIMI_INSTALL_URL RELE
 set kimiCommand $env(RELEASE_SKILL_KIMI_COMMAND)
 set installUrl $env(RELEASE_SKILL_KIMI_INSTALL_URL)
 set removePlugin $env(RELEASE_SKILL_KIMI_REMOVE_PLUGIN)
+set promptPattern {(?:(?:^|\\r|\\n)> |(?:^|\\r|\\n)(?:\\033\\[[0-9;?]*[ -/]*[@-~])*│[ \\t]*>[ \\t]*│(?:\\033\\[[0-9;?]*[ -/]*[@-~])*)(?![^\\n]|\\n)}
 spawn $kimiCommand
-expect -re {> $}
+expect -re $promptPattern
 ${removeCommand}send -- "/plugins install $installUrl\\r"
 expect {
   -nocase -re {trust and install} {
@@ -595,9 +742,9 @@ expect {
   timeout { exit 91 }
   eof { exit 92 }
 }
-expect -re {> $}
+expect -re $promptPattern
 send -- "/reload\\r"
-expect -re {> $}
+expect -re $promptPattern
 send -- "/exit\\r"
 expect eof
 `;
@@ -730,6 +877,12 @@ function aggregateStatus(results) {
 
 function failedHostResult(target, error) {
   const message = error?.message ?? String(error);
+  const details = error?.details;
+  const publicDetails = details && typeof details === 'object' && !Array.isArray(details)
+    ? Object.fromEntries(Object.entries(details).filter(([key]) => (
+      key !== 'foundationEnvelope' && key !== 'foundationStdout' && key !== 'foundationStderr'
+    )))
+    : details;
   return {
     host: target.host,
     unitId: target.unitId,
@@ -737,7 +890,7 @@ function failedHostResult(target, error) {
     error: message,
     reason: typeof error?.reason === 'string' ? error.reason : message,
     ...(error?.code !== undefined ? { code: error.code } : {}),
-    ...(error?.details !== undefined ? { details: error.details } : {}),
+    ...(publicDetails !== undefined ? { details: publicDetails } : {}),
   };
 }