release-skill 0.9.6 → 0.9.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-skill",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "description": "Safe preparation and frozen GitHub/npm production publishing with full happy end verification",
   "author": {
     "name": "广州市风荷科技有限公司"

package/platform-manifest.json

@@ -2,11 +2,11 @@
   "schemaVersion": "1.0.0",
   "platformId": "release-skill",
   "platformName": "release-skill Plugin Platform",
-  "version": "0.9.6",
+  "version": "0.9.8",
   "logicalRoot": "skills-src/",
-  "logicalRootDigest": "4338c7c5a7efd38ca372049526e5bdd198087491f76702cd21d491741bfad835",
-  "projectionDigest": "c4d40afd481d78907d51ef9be1dc2238834d566b9a9792f1d25da19f57368d7d",
-  "projectionId": "release-skill:platform:0.9.6",
+  "logicalRootDigest": "aec96745b30289ed48d576fbfc98ecd3aacb834f83394be76d4734d7d0fc0ad4",
+  "projectionDigest": "e5117d89c9f965e15a1464cc84f542cb1e75a685f842183d0cfc7a105ace5ceb",
+  "projectionId": "release-skill:platform:0.9.8",
   "manifestRequired": true,
   "projectionSources": {
     "skills-src-root": {

package/skills/release-finish/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: release-finish
-description: 发布达到 VERIFIED 后处理可选的本地收尾：按发布分支策略决定是否询问合并，并在用户确认后更新本机 Claude、Codex、Kimi、CodeBuddy/WorkBuddy 插件
+description: 发布达到 VERIFIED 后处理发布收尾：确认 postVerify 提案送达边界，按发布分支策略决定是否询问合并，并在用户确认后更新本机 Claude、Codex、Kimi、CodeBuddy/WorkBuddy 插件
 ---
 
 # release-finish
@@ -13,7 +13,7 @@ description: 发布达到 VERIFIED 后处理可选的本地收尾：按发布分
 
 这是发布后的独立收尾，不属于 `prepare → approve → publish → verify` 状态机。它不能把本机更新结果写成新的发布状态，也不能因为本机更新失败而降低 `VERIFIED`。
 
-默认只读取冻结计划和 verify 或 postVerify run。没有用户明确同意，不合并分支，不更新插件，不接受 Kimi 的安装信任提示。
+默认只读取冻结计划和 verify 或 postVerify run。没有用户明确同意，不合并分支，不更新插件。Kimi 只在插件信任界面中的仓库和标签都与冻结目标一致时确认安装；目录信任不自动确认。
 
 ## 先生成收尾清单
 
@@ -37,6 +37,14 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill-local-finish.mjs" \
 2. `merge.promptRequired=true` 时，向用户说明尚未覆盖的发布分支，并询问是否需要合并。用户同意后，先只读核对源分支、目标分支、工作区状态和项目既有合并方式，再用明确的分支名执行；本脚本不猜分支，也不自动推送。
 3. `localHostUpdate.promptRequired=true` 时，列出计划覆盖的宿主，询问是否更新本机插件。两个问题可以一次问完。
 
+## postVerify 提案送达边界
+
+`proposal-inbox` postVerify hook 只负责把冻结提案送到配置的接收端，并在 hook checkpoint 中记录送达结果。送达成功不表示提案已经应用，也不表示接收端完成了渲染或公开同步。
+
+接收端按照自己的 runbook 和治理要求审阅、应用、渲染并公开同步。release-finish 不内置某个接收端的仓库、命令或推送步骤，也不增加另一套收据、账本、Schema、状态机或 hook。
+
+本机宿主是否依赖某个市场，只根据冻结计划记录的真实安装来源判断。提案送达或某个接收端的处理结果不是所有宿主更新的统一前置条件；只有宿主的冻结安装来源确实指向该接收端产物时，才按接收端自己的 runbook 完成必要处理。
+
 ## 用户同意更新本机宿主
 
 把用户选择的宿主和清单返回的精确 `planDigest` 传回脚本：
@@ -54,8 +62,8 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill-local-finish.mjs" \
 
 只传用户选择且计划声明的宿主。宿主 CLI 不存在时返回 `SKIPPED_NOT_INSTALLED`。各宿主按以下规则处理：
 
-- Claude 先重新绑定冻结市场，再重新观察安装状态；旧插件若仍存在，才调用正式更新命令。Codex 继续按正式市场协议移除并安装冻结的 Git 引用。两者都在安装后核对插件、市场、版本和市场检出提交。
-- Kimi 的精确当前安装会在返回 `ALREADY_CURRENT` 前核对真实载荷；发生安装或迁移时，只在操作完成后核对结果。包名、版本、发布标签、已安装修订号和受管安装根必须与冻结计划一致；`.git` 只提供附加诊断，不是通过条件。旧的本地路径安装会在同一个受控终端交互界面（TUI）会话中先移除，再按发布标签安装、确认信任并重新加载。
+- Claude 或 Codex 只有在市场需要重绑时，才会在该宿主第一条写命令之前只读查询冻结的市场仓库、引用和提交。远端不可达、引用缺失或提交不一致时返回 `MANUAL_REQUIRED`，该宿主不执行市场或插件写入；其他已选宿主继续处理。精确当前安装仍核对真实载荷，但不强制联网。
+- Kimi 的精确当前安装会在返回 `ALREADY_CURRENT` 前核对真实载荷；发生安装或迁移时，只在操作完成后核对结果。配置根依次取显式 `kimiHome`、`KIMI_CODE_HOME`、用户主目录下的 `.kimi-code`，TUI 与安装后观察使用同一根。release-finish 当前只采用并验证 Kimi Code 的受控终端交互界面（TUI）路径：清理 ANSI/OSC 控制序列和软换行后，在插件信任对话框内分别核对冻结仓库与标签，确认选中 `Trust and install` 后才提交，再重新加载。出现 `Trust this folder?`、未知界面、超时、提前退出，或无法确认身份和选中项时返回 `MANUAL_REQUIRED` 或失败结果，不确认目录信任，也不继续安装。包名、版本、发布标签、已安装修订号和受管安装根必须与冻结计划一致；`.git` 只提供附加诊断，不是通过条件。旧的本地路径安装会在同一 TUI 会话中先移除，再按发布标签安装。
 - CodeBuddy/WorkBuddy 只处理同一 bundled-family 插件和市场。CodeBuddy 仅探测全局 `codebuddy`/`cbc`，由收尾脚本把 `CODEBUDDY_CONFIG_DIR` 固定为有效 `HOME`（环境未提供时取操作系统用户主目录）下名为 `.codebuddy` 的目录；WorkBuddy 仅在 macOS 探测 WorkBuddy 应用内嵌 CLI，由收尾脚本把 `CODEBUDDY_CONFIG_DIR` 与 `WORKBUDDY_CONFIG_DIR` 同时固定为有效 `HOME` 下名为 `.workbuddy` 的目录，绝不把两者互作回退。只有冻结标签与计划声明的可变分支都从同一远端解析到冻结提交时，才调用正式市场更新和插件更新命令；完成后重新读取安装列表，并精确核对唯一条目的市场、版本和修订号。目标未安装、来源不符、远端不可访问或身份不一致时返回 `MANUAL_REQUIRED`，不修改宿主。非 macOS 的 WorkBuddy 返回 `SKIPPED_UNSUPPORTED_PLATFORM`。
 
 任何宿主失败都保留其他宿主的实际结果，不回滚，也不把失败冒充成功。

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

@@ -1,6 +1,6 @@
 ---
 name: release-finish
-description: 发布达到 VERIFIED 后处理可选的本地收尾：按发布分支策略决定是否询问合并，并在用户确认后更新本机 Claude、Codex、Kimi、CodeBuddy/WorkBuddy 插件
+description: 发布达到 VERIFIED 后处理发布收尾：确认 postVerify 提案送达边界，按发布分支策略决定是否询问合并，并在用户确认后更新本机 Claude、Codex、Kimi、CodeBuddy/WorkBuddy 插件
 ---
 
 # release-finish
@@ -13,7 +13,7 @@ description: 发布达到 VERIFIED 后处理可选的本地收尾：按发布分
 
 这是发布后的独立收尾，不属于 `prepare → approve → publish → verify` 状态机。它不能把本机更新结果写成新的发布状态，也不能因为本机更新失败而降低 `VERIFIED`。
 
-默认只读取冻结计划和 verify 或 postVerify run。没有用户明确同意，不合并分支，不更新插件，不接受 Kimi 的安装信任提示。
+默认只读取冻结计划和 verify 或 postVerify run。没有用户明确同意，不合并分支，不更新插件。Kimi 只在插件信任界面中的仓库和标签都与冻结目标一致时确认安装；目录信任不自动确认。
 
 ## 先生成收尾清单
 
@@ -37,6 +37,14 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill-local-finish.mjs" \
 2. `merge.promptRequired=true` 时，向用户说明尚未覆盖的发布分支，并询问是否需要合并。用户同意后，先只读核对源分支、目标分支、工作区状态和项目既有合并方式，再用明确的分支名执行；本脚本不猜分支，也不自动推送。
 3. `localHostUpdate.promptRequired=true` 时，列出计划覆盖的宿主，询问是否更新本机插件。两个问题可以一次问完。
 
+## postVerify 提案送达边界
+
+`proposal-inbox` postVerify hook 只负责把冻结提案送到配置的接收端，并在 hook checkpoint 中记录送达结果。送达成功不表示提案已经应用，也不表示接收端完成了渲染或公开同步。
+
+接收端按照自己的 runbook 和治理要求审阅、应用、渲染并公开同步。release-finish 不内置某个接收端的仓库、命令或推送步骤，也不增加另一套收据、账本、Schema、状态机或 hook。
+
+本机宿主是否依赖某个市场，只根据冻结计划记录的真实安装来源判断。提案送达或某个接收端的处理结果不是所有宿主更新的统一前置条件；只有宿主的冻结安装来源确实指向该接收端产物时，才按接收端自己的 runbook 完成必要处理。
+
 ## 用户同意更新本机宿主
 
 把用户选择的宿主和清单返回的精确 `planDigest` 传回脚本：
@@ -54,8 +62,8 @@ node "${CLAUDE_PLUGIN_ROOT}/bin/release-skill-local-finish.mjs" \
 
 只传用户选择且计划声明的宿主。宿主 CLI 不存在时返回 `SKIPPED_NOT_INSTALLED`。各宿主按以下规则处理：
 
-- Claude 先重新绑定冻结市场，再重新观察安装状态；旧插件若仍存在，才调用正式更新命令。Codex 继续按正式市场协议移除并安装冻结的 Git 引用。两者都在安装后核对插件、市场、版本和市场检出提交。
-- Kimi 的精确当前安装会在返回 `ALREADY_CURRENT` 前核对真实载荷；发生安装或迁移时，只在操作完成后核对结果。包名、版本、发布标签、已安装修订号和受管安装根必须与冻结计划一致；`.git` 只提供附加诊断，不是通过条件。旧的本地路径安装会在同一个受控终端交互界面（TUI）会话中先移除，再按发布标签安装、确认信任并重新加载。
+- Claude 或 Codex 只有在市场需要重绑时，才会在该宿主第一条写命令之前只读查询冻结的市场仓库、引用和提交。远端不可达、引用缺失或提交不一致时返回 `MANUAL_REQUIRED`，该宿主不执行市场或插件写入；其他已选宿主继续处理。精确当前安装仍核对真实载荷，但不强制联网。
+- Kimi 的精确当前安装会在返回 `ALREADY_CURRENT` 前核对真实载荷；发生安装或迁移时，只在操作完成后核对结果。配置根依次取显式 `kimiHome`、`KIMI_CODE_HOME`、用户主目录下的 `.kimi-code`，TUI 与安装后观察使用同一根。release-finish 当前只采用并验证 Kimi Code 的受控终端交互界面（TUI）路径：清理 ANSI/OSC 控制序列和软换行后，在插件信任对话框内分别核对冻结仓库与标签，确认选中 `Trust and install` 后才提交，再重新加载。出现 `Trust this folder?`、未知界面、超时、提前退出，或无法确认身份和选中项时返回 `MANUAL_REQUIRED` 或失败结果，不确认目录信任，也不继续安装。包名、版本、发布标签、已安装修订号和受管安装根必须与冻结计划一致；`.git` 只提供附加诊断，不是通过条件。旧的本地路径安装会在同一 TUI 会话中先移除，再按发布标签安装。
 - CodeBuddy/WorkBuddy 只处理同一 bundled-family 插件和市场。CodeBuddy 仅探测全局 `codebuddy`/`cbc`，由收尾脚本把 `CODEBUDDY_CONFIG_DIR` 固定为有效 `HOME`（环境未提供时取操作系统用户主目录）下名为 `.codebuddy` 的目录；WorkBuddy 仅在 macOS 探测 WorkBuddy 应用内嵌 CLI，由收尾脚本把 `CODEBUDDY_CONFIG_DIR` 与 `WORKBUDDY_CONFIG_DIR` 同时固定为有效 `HOME` 下名为 `.workbuddy` 的目录，绝不把两者互作回退。只有冻结标签与计划声明的可变分支都从同一远端解析到冻结提交时，才调用正式市场更新和插件更新命令；完成后重新读取安装列表，并精确核对唯一条目的市场、版本和修订号。目标未安装、来源不符、远端不可访问或身份不一致时返回 `MANUAL_REQUIRED`，不修改宿主。非 macOS 的 WorkBuddy 返回 `SKIPPED_UNSUPPORTED_PLATFORM`。
 
 任何宿主失败都保留其他宿主的实际结果，不回滚，也不把失败冒充成功。

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

@@ -35,7 +35,7 @@ const SAFE_ENV_KEYS = Object.freeze([
   'PATH', 'HOME', 'USER', 'LANG', 'LC_ALL', 'LC_CTYPE', 'TERM', 'TMPDIR',
   'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY', 'http_proxy', 'https_proxy', 'no_proxy',
   'SSL_CERT_FILE', 'SSL_CERT_DIR', 'NODE_EXTRA_CA_CERTS',
-  'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'KIMI_CONFIG_DIR',
+  'CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'KIMI_CODE_HOME',
   'CODEBUDDY_CONFIG_DIR', 'WORKBUDDY_CONFIG_DIR',
 ]);
 const CODEBUDDY_PLUGIN_LIST_ARGS = Object.freeze(['plugin', 'list', '--json']);
@@ -422,7 +422,7 @@ function hostEnvironment(host, { kimiHome } = {}) {
     env.CODEBUDDY_CONFIG_DIR = join(env.HOME, '.workbuddy');
     env.WORKBUDDY_CONFIG_DIR = join(env.HOME, '.workbuddy');
   }
-  if (host === 'kimi' && kimiHome) env.KIMI_CONFIG_DIR = kimiHome;
+  if (host === 'kimi' && kimiHome) env.KIMI_CODE_HOME = kimiHome;
   return env;
 }
 
@@ -647,6 +647,67 @@ function normalizeGitSource(source) {
     .replace(/\/$/u, '');
 }
 
+function parseFrozenRemoteRef(target, stdout) {
+  const directRefs = new Map();
+  const peeledRefs = new Map();
+  const expected = target.marketplaceRef;
+  const allowedDirect = expected.startsWith('refs/')
+    ? new Set([expected])
+    : new Set([`refs/heads/${expected}`, `refs/tags/${expected}`]);
+  for (const line of String(stdout ?? '').split(/\r?\n/u)) {
+    if (line.length === 0) continue;
+    const match = /^([a-f0-9]{40})\t([^\s]+)$/u.exec(line);
+    if (!match) throw new Error('git ls-remote returned an invalid line');
+    const [, commit, remoteRef] = match;
+    const peeled = remoteRef.endsWith('^{}');
+    const direct = peeled ? remoteRef.slice(0, -3) : remoteRef;
+    if (!allowedDirect.has(direct)) {
+      throw new Error(`git ls-remote returned an unexpected ref ${remoteRef}`);
+    }
+    const destination = peeled ? peeledRefs : directRefs;
+    const previous = destination.get(direct);
+    if (previous && previous !== commit) {
+      throw new Error(`git ls-remote returned conflicting values for ${remoteRef}`);
+    }
+    destination.set(direct, commit);
+  }
+  const resolved = [...allowedDirect]
+    .filter((remoteRef) => directRefs.has(remoteRef) || peeledRefs.has(remoteRef))
+    .map((remoteRef) => peeledRefs.get(remoteRef) ?? directRefs.get(remoteRef));
+  return {
+    found: resolved.length > 0,
+    exact: resolved.length > 0 && resolved.every((commit) => commit === target.marketplaceCommit),
+  };
+}
+
+async function preflightStructuredMarketplace(target, env, run) {
+  try {
+    const observed = await run('git', [
+      'ls-remote', '--exit-code', `https://${target.githubHost}/${target.marketplaceRepo}.git`,
+      target.marketplaceRef, `${target.marketplaceRef}^{}`,
+    ], { env, timeout: 30_000 });
+    const remote = parseFrozenRemoteRef(target, observed.stdout);
+    if (!remote.found) {
+      return {
+        ok: false,
+        reason: `${target.host} frozen marketplace ref ${target.marketplaceRef} is missing`,
+      };
+    }
+    if (!remote.exact) {
+      return {
+        ok: false,
+        reason: `${target.host} frozen marketplace ref ${target.marketplaceRef} does not resolve to ${target.marketplaceCommit}`,
+      };
+    }
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `${target.host} could not prove the frozen marketplace ref: ${error?.message ?? String(error)}`,
+    };
+  }
+}
+
 async function observeMarketplace(target, command, env, run) {
   const listed = await run(command, ['plugin', 'marketplace', 'list', '--json'], { env });
   const parsed = parseJson(listed.stdout, `${target.host} marketplace list`);
@@ -835,6 +896,11 @@ async function runStructuredUpdate(target, detected, run, {
     return { status: 'ALREADY_CURRENT', version: target.version };
   }
 
+  if (!before.marketplace.exact) {
+    const preflight = await preflightStructuredMarketplace(target, env, run);
+    if (!preflight.ok) return { status: 'MANUAL_REQUIRED', reason: preflight.reason };
+  }
+
   const marketplaceRebound = await bindStructuredMarketplace(target, command, env, run, before);
   const current = target.host === 'claude' && marketplaceRebound
     ? await observeStructuredTarget(target, command, env, run)
@@ -898,49 +964,205 @@ function parseCodeBuddyRemoteObservation(target, stdout) {
 
 function kimiExpectProgram({ removePlugin } = {}) {
   const removeCommand = removePlugin
-    ? `send -- "/plugins remove $removePlugin\\r"
+    ? `submitCommand "/plugins remove $removePlugin"
 expect {
   -nocase -re {(remove|delete|uninstall).*(confirm|sure)|(confirm|sure).*(remove|delete|uninstall)} {
     expect {
-      -ex $removePlugin { send -- "\\033\\[B\\r" }
-      timeout { exit 95 }
-      eof { exit 96 }
+      -ex $removePlugin {
+        send -- "\\033\\[B"
+        send -- "\\033\\[13u"
+      }
+      timeout { failTimeout remove-confirmation 125 127 }
+      eof { failEof remove-confirmation 126 }
+    }
+    expect {
+      -nocase -re {Trust this folder\\?} { directoryTrust }
+      -re $promptPattern {}
+      timeout { failTimeout remove-prompt 128 130 }
+      eof { failEof remove-prompt 129 }
     }
-    expect -re $promptPattern
   }
   -re $promptPattern {}
-  timeout { exit 93 }
-  eof { exit 94 }
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  timeout { failTimeout remove-dialog 122 124 }
+  eof { failEof remove-dialog 123 }
 }
 `
     : '';
-  return `set timeout 180
-foreach variable {RELEASE_SKILL_KIMI_COMMAND RELEASE_SKILL_KIMI_INSTALL_URL RELEASE_SKILL_KIMI_REMOVE_PLUGIN} {
+  return `set timeout 240
+foreach variable {RELEASE_SKILL_KIMI_COMMAND RELEASE_SKILL_KIMI_INSTALL_URL RELEASE_SKILL_KIMI_REMOVE_PLUGIN RELEASE_SKILL_KIMI_EXPECTED_REPO RELEASE_SKILL_KIMI_EXPECTED_TAG} {
   if {![info exists env($variable)]} { exit 90 }
 }
 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)}
+set expectedRepo $env(RELEASE_SKILL_KIMI_EXPECTED_REPO)
+set expectedTag $env(RELEASE_SKILL_KIMI_EXPECTED_TAG)
+set promptPattern {(?:(?:^|\\r|\\n)> (?:\\r*\\n|$)|(?:^|\\r|\\n)(?:(?:\\033\\[[0-9;?]*[ -/]*[@-~])|\\033\\][^\\x07]*\\x07|[ \\t])*│[^\\r\\n]*>[^\\r\\n]*│(?:(?:\\033\\[[0-9;?]*[ -/]*[@-~])|\\033\\][^\\x07]*\\x07|[ \\t])*(?:\\r*\\n|$))}
+
+proc cleanScreen {value} {
+  regsub -all {\\033\\[[0-9;?]*[ -/]*[@-~]} $value {} value
+  regsub -all {\\033\\][^\\x07]*\\x07} $value {} value
+  regsub -all {\\r} $value {} value
+  return $value
+}
+
+proc compactScreen {value} {
+  set value [cleanScreen $value]
+  regsub -all {[[:space:]]+} $value {} value
+  return [string tolower $value]
+}
+
+proc extractPluginTrustDialog {value} {
+  set cleaned [cleanScreen $value]
+  set lowered [string tolower $cleaned]
+  set dialogStart -1
+  foreach marker {"install third-party plugin " "trust and install from "} {
+    set markerStart [string last $marker $lowered]
+    if {$markerStart > $dialogStart} { set dialogStart $markerStart }
+  }
+  if {$dialogStart < 0} { return "" }
+  return [string range $cleaned $dialogStart end]
+}
+
+proc failTimeout {state timeoutCode unknownCode} {
+  global expect_out
+  set buffer ""
+  if {[info exists expect_out(buffer)]} { set buffer [string trim [cleanScreen $expect_out(buffer)]] }
+  if {$buffer ne ""} {
+    puts stderr "KIMI_TUI_STATE:$state:unknown"
+    exit $unknownCode
+  }
+  puts stderr "KIMI_TUI_STATE:$state:timeout"
+  exit $timeoutCode
+}
+
+proc failEof {state code} {
+  puts stderr "KIMI_TUI_STATE:$state:eof"
+  exit $code
+}
+
+proc directoryTrust {} {
+  puts stderr "KIMI_TUI_STATE:directory-trust:manual-required"
+  exit 80
+}
+
+proc submitCommand {command} {
+  send -- "\\033\\[200~"
+  send -- $command
+  send -- "\\033\\[201~"
+  send -- "\\033\\[13u"
+}
+
 spawn $kimiCommand
-expect -re $promptPattern
-${removeCommand}send -- "/plugins install $installUrl\\r"
+if {[catch {exec stty columns 240 rows 60 < $spawn_out(slave,name)} resizeError]} {
+  puts stderr "KIMI_TUI_STATE:terminal-size:failed"
+  exit 131
+}
 expect {
-  -nocase -re {trust and install} {
-    expect {
-      -ex $installUrl { send -- "\\033\\[B\\r" }
-      timeout { exit 97 }
-      eof { exit 98 }
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -re $promptPattern {}
+  timeout { failTimeout initial-prompt 101 103 }
+  eof { failEof initial-prompt 102 }
+}
+${removeCommand}submitCommand "/plugins install $installUrl"
+set dialogBuffer ""
+expect {
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {(?:Install third-party plugin|Trust and install from)[ \\t]} {
+    append dialogBuffer $expect_out(buffer)
+  }
+  timeout { failTimeout plugin-trust-anchor 104 106 }
+  eof { failEof plugin-trust-anchor 105 }
+}
+expect {
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {❯[^\\r\\n]*(?:Exit|Cancel|Trust and install)} {
+    append dialogBuffer $expect_out(buffer)
+  }
+  -re {❯[^\\r\\n]*\\r*\\n} {
+    puts stderr "KIMI_TUI_STATE:plugin-trust-selected-row:unknown"
+    exit 134
+  }
+  timeout {
+    puts stderr "KIMI_TUI_STATE:plugin-trust-selected-row:timeout"
+    exit 132
+  }
+  eof { failEof plugin-trust-selected-row 133 }
+}
+
+set dialog [extractPluginTrustDialog $dialogBuffer]
+if {$dialog eq ""} {
+  puts stderr "KIMI_TUI_STATE:plugin-trust:dialog-unknown"
+  exit 113
+}
+set compactDialog [compactScreen $dialog]
+if {[string first [string tolower [compactScreen $expectedRepo]] $compactDialog] < 0} {
+  puts stderr "KIMI_TUI_STATE:plugin-trust:repo-mismatch"
+  exit 111
+}
+if {[string first [string tolower [compactScreen $expectedTag]] $compactDialog] < 0} {
+  puts stderr "KIMI_TUI_STATE:plugin-trust:tag-mismatch"
+  exit 112
+}
+if {[regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*trust and install} $dialog]} {
+  send -- "\\033\\[13u"
+} elseif {[regexp -nocase {(^|\\n)[^\\n]*❯[^\\n]*(cancel|exit)} $dialog]} {
+  send -- "\\033\\[B"
+  expect {
+    -nocase -re {Trust this folder\\?} { directoryTrust }
+    -nocase -re {❯[^\\r\\n]*Trust and install} {}
+    -re {❯[^\\r\\n]*\\r*\\n} {
+      puts stderr "KIMI_TUI_STATE:plugin-trust-confirm-selection:unknown"
+      exit 109
     }
+    timeout { failTimeout plugin-trust-confirm-selection 107 109 }
+    eof { failEof plugin-trust-confirm-selection 108 }
   }
-  timeout { exit 91 }
-  eof { exit 92 }
+  send -- "\\033\\[13u"
+} else {
+  puts stderr "KIMI_TUI_STATE:plugin-trust:selection-unknown"
+  exit 113
+}
+
+expect {
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -nocase -re {Install finished[^\\r\\n]*see details below\\.} {}
+  -nocase -re {Installing plugin from[^\\r\\n]*(?:\\r|\\n)} {
+    exp_continue -continue_timer
+  }
+  -nocase -re {Install failed:[^\\r\\n]*} {
+    puts stderr "KIMI_TUI_STATE:install-result:failed"
+    exit 135
+  }
+  -nocase -re {(^|\\r|\\n)Install[^\\r\\n]*\\r*\\n} {
+    puts stderr "KIMI_TUI_STATE:install-result:unknown"
+    exit 138
+  }
+  timeout {
+    puts stderr "KIMI_TUI_STATE:install-result:timeout"
+    exit 136
+  }
+  eof { failEof install-result 137 }
+}
+expect {
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -re $promptPattern {}
+  timeout { failTimeout post-install-prompt 114 116 }
+  eof { failEof post-install-prompt 115 }
+}
+submitCommand "/reload"
+expect {
+  -nocase -re {Trust this folder\\?} { directoryTrust }
+  -re $promptPattern {}
+  timeout { failTimeout reload-prompt 117 119 }
+  eof { failEof reload-prompt 118 }
+}
+submitCommand "/exit"
+expect {
+  eof { puts stderr "KIMI_TUI_STATE:exit-eof:eof" }
+  timeout { failTimeout exit-eof 120 121 }
 }
-expect -re $promptPattern
-send -- "/reload\\r"
-expect -re $promptPattern
-send -- "/exit\\r"
-expect eof
 `;
 }
 
@@ -1018,7 +1240,7 @@ async function runKimiUpdate(target, detected, run, kimiHome, {
     });
     return { status: 'ALREADY_CURRENT', version: target.version };
   }
-  await withTemporaryWorkspace(async (workspace) => {
+  const tuiOutcome = await withTemporaryWorkspace(async (workspace) => {
     const checkout = join(workspace.root, 'plugin');
     await run('git', [
       'clone', '--depth', '1', '--branch', target.pluginTag, '--single-branch',
@@ -1033,18 +1255,31 @@ async function runKimiUpdate(target, detected, run, kimiHome, {
     }
     const installUrl = `https://github.com/${target.pluginRepo}/releases/tag/${target.pluginTag}`;
     const removePlugin = before.source === 'legacy' ? target.plugin : '';
-    await run(detected.expectCommand, ['-c', kimiExpectProgram({
-      ...(removePlugin ? { removePlugin } : {}),
-    })], {
-      timeout: 240_000,
-      env: {
-        ...env,
-        RELEASE_SKILL_KIMI_COMMAND: detected.command,
-        RELEASE_SKILL_KIMI_INSTALL_URL: installUrl,
-        RELEASE_SKILL_KIMI_REMOVE_PLUGIN: removePlugin,
-      },
-    });
+    try {
+      await run(detected.expectCommand, ['-c', kimiExpectProgram({
+        ...(removePlugin ? { removePlugin } : {}),
+      })], {
+        timeout: Math.max(300_000, target.timeoutMs),
+        env: {
+          ...env,
+          RELEASE_SKILL_KIMI_COMMAND: detected.command,
+          RELEASE_SKILL_KIMI_INSTALL_URL: installUrl,
+          RELEASE_SKILL_KIMI_REMOVE_PLUGIN: removePlugin,
+          RELEASE_SKILL_KIMI_EXPECTED_REPO: `https://github.com/${target.pluginRepo}`,
+          RELEASE_SKILL_KIMI_EXPECTED_TAG: target.pluginTag,
+        },
+      });
+    } catch (error) {
+      if (error?.exitStatus === 80) {
+        return {
+          status: 'MANUAL_REQUIRED',
+          reason: 'Kimi requires folder trust; release-finish did not confirm the folder or continue installation',
+        };
+      }
+      throw error;
+    }
   }, { prefix: 'release-skill-kimi-update-' });
+  if (tuiOutcome) return tuiOutcome;
   const after = await observeKimiTarget(target, kimiHome, run);
   if (!after.exact) throw new Error('Kimi did not report the frozen plugin identity after TUI installation');
   await verifyStructuredInstalledPayload({
@@ -1098,7 +1333,7 @@ async function updateLocalHostPluginsInternal({
   kimiHome,
   verifyInstalledPayload = verifyInstalledMarketplacePayload,
 } = {}) {
-  const effectiveKimiHome = kimiHome ?? process.env.KIMI_CONFIG_DIR ?? join(homedir(), '.kimi-code');
+  const effectiveKimiHome = kimiHome ?? process.env.KIMI_CODE_HOME ?? join(homedir(), '.kimi-code');
   const checklist = derivePostReleaseChecklist(plan, { postVerifyComplete: true });
   if (confirmPlanDigest !== plan.digest) {
     throw new Error('plan digest confirmation does not match the frozen release plan');

package/src/commands/prepare.mjs

@@ -82,7 +82,7 @@ import {
   normalizeHostId,
   buildExpectedStandaloneIndexInstallIdentity,
 } from '../platforms/registry.mjs';
-import { deriveSurfaceHostBinding, pluginRootFromManifestRelativePath } from '../core/surface-host-bindings.mjs';
+import { deriveSurfaceHostBinding, groupSurfaceHostBindings, pluginRootFromManifestRelativePath } from '../core/surface-host-bindings.mjs';
 import { validateMarketplaceSourceSelection, MARKETPLACE_SOURCE_TYPES, resolvePluginManifestFromMarketplaceEntrySource, resolveMarketplaceRoot } from '../adapters/plugin-marketplace.mjs';
 import { buildInstallationContract, computeInstallationContractDigest, INSTALLATION_CONTRACT_ALGORITHM_VERSION } from '../core/installation-contract.mjs';
 import {
@@ -2818,10 +2818,11 @@ async function runPrepareSkillResourceClosureGate({
       if (binding) surfaceHostBindings.push(binding);
     }
 
+    const { checkerBindings, coverageClaims } = groupSurfaceHostBindings(surfaceHostBindings);
     const closureResult = await checkSkillResourceClosure({
       snapshotDir: manifest.outputDir,
       host: 'root',
-      surfaceHostBindings,
+      surfaceHostBindings: checkerBindings,
     });
 
     // G5: bind execution time + exit code into the frozen receipt.
@@ -2880,6 +2881,7 @@ async function runPrepareSkillResourceClosureGate({
     const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
       expectedHosts,
       closureResult.surfaces,
+      coverageClaims,
     );
     if (!hostCoverage.passed) {
       await evidence.append({
@@ -2908,7 +2910,7 @@ async function runPrepareSkillResourceClosureGate({
     // 含一个技能（binding-surface existence）。G4 按宿主名覆盖，这里按
     // 绑定表面路径覆盖 —— 例如 manifest 指向 './adapters/claude/skills/'
     // 但 publicFiles 丢弃该目录时，绑定表面缺失必须失败关闭。
-    for (const binding of surfaceHostBindings) {
+    for (const binding of coverageClaims) {
       const boundSurface = closureResult.surfaces.find(
         (surface) => surface.id === binding.surfaceId,
       );

package/src/commands/publish.mjs

@@ -27,8 +27,8 @@
 
 import { readFile, mkdir } from 'node:fs/promises';
 import { isAbsolute, join, relative } from 'node:path';
-import { PLATFORMS } from '../platforms/registry.mjs';
-import { deriveSurfaceHostBinding, pluginRootFromManifestRelativePath } from '../core/surface-host-bindings.mjs';
+import { PLATFORMS, normalizeHostId } from '../platforms/registry.mjs';
+import { deriveSurfaceHostBinding, groupSurfaceHostBindings, pluginRootFromManifestRelativePath } from '../core/surface-host-bindings.mjs';
 
 import { assertImmutablePlanAuthority, computePlanDigest, validatePlan, validatePlanActionCompleteness } from '../core/plan.mjs';
 import {
@@ -48,6 +48,7 @@ import {
   assertSkillResourceClosureReceipt,
   checkSkillResourceClosure,
   createSkillResourceClosureReceipt,
+  evaluateDeclaredHostSurfaceCoverage,
 } from '../core/skill-resource-closure.mjs';
 import {
   ADAPTER_ACTION_TYPE_MAP,
@@ -672,10 +673,11 @@ export async function publishRelease(options) {
           });
           if (binding) surfaceHostBindings.push(binding);
         }
+        const { checkerBindings, coverageClaims } = groupSurfaceHostBindings(surfaceHostBindings);
         const closureResult = await checkSkillResourceClosure({
           snapshotDir,
           host: 'root',
-          surfaceHostBindings,
+          surfaceHostBindings: checkerBindings,
         });
         if (closureResult.findings.length > 0) {
           await evidence.append({
@@ -691,6 +693,31 @@ export async function publishRelease(options) {
             { unitId, findings: closureResult.findings },
           );
         }
+        const expectedHosts = [];
+        for (const distribution of frozenUnit?.distributions ?? []) {
+          const platform = PLATFORMS.find((item) => item.distributionType === distribution.type);
+          if (platform) expectedHosts.push(await normalizeHostId(platform.buildAdapter.name));
+        }
+        const hostCoverage = evaluateDeclaredHostSurfaceCoverage(
+          expectedHosts,
+          closureResult.surfaces,
+          coverageClaims,
+        );
+        if (!hostCoverage.passed) {
+          await evidence.append({
+            phase: 'safety-gate',
+            gate: 'skill-resource-closure',
+            status: 'failed',
+            unitId,
+            reason: 'declared-host-surface-missing',
+            missingHosts: hostCoverage.missing,
+          });
+          throw new ReleaseError(
+            GATE_FAILED,
+            `skill resource closure recheck failed for unit "${unitId}": declared host surface(s) missing or empty: ${hostCoverage.missing.map((item) => item.host).join(', ')}`,
+            { unitId, missingHosts: hostCoverage.missing },
+          );
+        }
         // G5: preparedAt/exitCode are record-layer fields frozen by prepare
         // (bound by the plan digest); they cannot be recomputed from the
         // snapshot, so the recheck carries them forward from the expected

package/src/commands/ship.mjs

@@ -8,6 +8,7 @@ import {
   effectiveHookRequiresApproval,
   normalizePostPublishView,
   postPublishActionId,
+  requiresPostPublishDistribution,
 } from '../core/postpublish.mjs';
 import {
   derivePostReleaseChecklist,
@@ -652,13 +653,10 @@ export async function advanceShip(options = {}, injected = {}) {
 
   if (state.status === 'PUBLISHED' || state.status === 'NEEDS_MANUAL_ATTESTATIONS') {
     // Step 1: Check if postPublish requires distribution.
-    // Hooks-only declarations (no targets) still route through distribute.
-    // §4.3 unified normalization: v3 empty arrays carry no distribute work;
-    // legacy absent postPublish resolves to the same empty view.
+    // Only targets and distribute-phase hooks route through distribute;
+    // phase:postVerify hooks belong to their independent post-VERIFIED run.
     const plan = JSON.parse(await readFile(state.planPath, 'utf8'));
-    const hasDistributeWork = normalizePostPublishView(plan).some((declaration) =>
-      (declaration.targets?.length ?? 0) > 0 || (declaration.hooks?.length ?? 0) > 0);
-    const needsDistribution = hasDistributeWork;
+    const needsDistribution = requiresPostPublishDistribution(plan);
     if (needsDistribution && deps.distributeRelease) {
       state.status = 'DISTRIBUTING';
       await writeJsonAtomic(statePath, state);