release-skill 0.9.7 → 0.9.9

package/adapters/workbuddy/bin/release-skill.bundle.mjs

@@ -9,9 +9,9 @@ const __bundlePkgRoot = __bundleResolve(__bundleDirname(__bundleFileURLToPath(im
 // Provide a real require() for CJS packages bundled into ESM (e.g. yaml, ajv).
 const __bundleRealRequire = __bundleCreateRequire(import.meta.url);
 // Package identity injected at build time — closure-independent --version probe.
-const __bundlePkg = Object.freeze({"name":"release-skill","version":"0.9.7"});
+const __bundlePkg = Object.freeze({"name":"release-skill","version":"0.9.9"});
 // Build-time source digest for the BUNDLE_STALE freshness gate (see above).
-const __bundleSourceDigest = "938bc6828f17e2248a4fe167bcd3353b43848ec1a494dc17dc663d390847150c";
+const __bundleSourceDigest = "ef2ec274a982afcf48acdbccdf32439d199dd1d79b4a39b1aeaef23195fadbfb";
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -45592,6 +45592,9 @@ function normalizePostPublishView(plan) {
     { planVersion: version }
   );
 }
+function requiresPostPublishDistribution(plan) {
+  return normalizePostPublishView(plan).some((declaration) => (declaration.targets?.length ?? 0) > 0 || (declaration.hooks ?? []).some((hook) => hook.phase === void 0 || hook.phase === "distribute"));
+}
 function validatePostPublishHookIdUniqueness(declarations) {
   const explicitHookIdOwner = /* @__PURE__ */ new Map();
   for (const declaration of declarations ?? []) {
@@ -45759,6 +45762,7 @@ var init_postpublish = __esm({
     __name(validatePostPublishHookEntry, "validatePostPublishHookEntry");
     __name(validatePostPublishDeclaration, "validatePostPublishDeclaration");
     __name(normalizePostPublishView, "normalizePostPublishView");
+    __name(requiresPostPublishDistribution, "requiresPostPublishDistribution");
     __name(validatePostPublishHookIdUniqueness, "validatePostPublishHookIdUniqueness");
     __name(postPublishActionId, "postPublishActionId");
     __name(orderTargetsByDependency, "orderTargetsByDependency");
@@ -113357,8 +113361,7 @@ async function verifyRelease(options) {
         { sourceRunStatus: sourceRun.status }
       );
     }
-    const postPublishDeclarations = normalizePostPublishView(plan);
-    const requiresDistribution = postPublishDeclarations.some((declaration) => (declaration.targets?.length ?? 0) > 0 || (declaration.hooks?.length ?? 0) > 0);
+    const requiresDistribution = requiresPostPublishDistribution(plan);
     if (requiresDistribution) {
       await evidence.append({ phase: "verify", step: "distribute-run-discovery", status: "started" });
       const distributeCandidates = await discoverDistributeRuns({ planPath, plan }) ?? [];
@@ -114547,7 +114550,7 @@ async function readRunRecovery(runPath, options = {}) {
       }
     } else if (["publish", "reconcile"].includes(command2)) {
       if (run6.status === "PUBLISHED") {
-        const needsDistribution = normalizePostPublishView(plan).some((declaration) => (declaration.targets?.length ?? 0) > 0 || (declaration.hooks?.length ?? 0) > 0);
+        const needsDistribution = requiresPostPublishDistribution(plan);
         code = needsDistribution ? "DISTRIBUTE" : "VERIFY";
       } else if (run6.status === "PARTIAL") {
         code = "RECONCILE";
@@ -131814,7 +131817,7 @@ function hostEnvironment(host, { kimiHome } = {}) {
     env.CODEBUDDY_CONFIG_DIR = join27(env.HOME, ".workbuddy");
     env.WORKBUDDY_CONFIG_DIR = join27(env.HOME, ".workbuddy");
   }
-  if (host === "kimi" && kimiHome) env.KIMI_CONFIG_DIR = kimiHome;
+  if (host === "kimi" && kimiHome) env.KIMI_CODE_HOME = kimiHome;
   return env;
 }
 async function defaultRun(command2, args2, options = {}) {
@@ -131991,6 +131994,64 @@ function exactPluginObservation(target, stdout) {
 function normalizeGitSource(source) {
   return String(source ?? "").replace(/^git\+/, "").replace(/^https:\/\/github\.com\//, "").replace(/^git@github\.com:/, "").replace(/\.git$/u, "").replace(/\/$/u, "");
 }
+function parseFrozenRemoteRef(target, stdout) {
+  const directRefs = /* @__PURE__ */ new Map();
+  const peeledRefs = /* @__PURE__ */ new Map();
+  const expected = target.marketplaceRef;
+  const allowedDirect = expected.startsWith("refs/") ? /* @__PURE__ */ new Set([expected]) : /* @__PURE__ */ 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, run6) {
+  try {
+    const observed = await run6("git", [
+      "ls-remote",
+      "--exit-code",
+      `https://${target.githubHost}/${target.marketplaceRepo}.git`,
+      target.marketplaceRef,
+      `${target.marketplaceRef}^{}`
+    ], { env, timeout: 3e4 });
+    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, command2, env, run6) {
   const listed = await run6(command2, ["plugin", "marketplace", "list", "--json"], { env });
   const parsed = parseJson2(listed.stdout, `${target.host} marketplace list`);
@@ -132176,6 +132237,10 @@ async function runStructuredUpdate(target, detected, run6, {
     });
     return { status: "ALREADY_CURRENT", version: target.version };
   }
+  if (!before.marketplace.exact) {
+    const preflight = await preflightStructuredMarketplace(target, env, run6);
+    if (!preflight.ok) return { status: "MANUAL_REQUIRED", reason: preflight.reason };
+  }
   const marketplaceRebound = await bindStructuredMarketplace(target, command2, env, run6, before);
   const current = target.host === "claude" && marketplaceRebound ? await observeStructuredTarget(target, command2, env, run6) : before;
   const platform = getPlatform(target.host);
@@ -132229,48 +132294,222 @@ function parseCodeBuddyRemoteObservation(target, stdout) {
   };
 }
 function kimiExpectProgram({ removePlugin } = {}) {
-  const removeCommand = removePlugin ? `send -- "/plugins remove $removePlugin\\r"
+  const removeCommand = removePlugin ? `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;?]*[ -/]*[@-~])*\u2502[ \\t]*>[ \\t]*\u2502(?:\\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])*\u2502[^\\r\\n]*>[^\\r\\n]*\u2502(?:(?:\\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 $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 extractPluginTrustIdentity {value} {
+  set cleaned [cleanScreen $value]
+  set lowered [string tolower $cleaned]
+  set identityStart -1
+  foreach marker {"install third-party plugin " "trust and install from "} {
+    set markerStart [string last $marker $lowered]
+    if {$markerStart >= 0 && $markerStart + [string length $marker] > $identityStart} {
+      set identityStart [expr {$markerStart + [string length $marker]}]
+    }
+  }
+  if {$identityStart < 0} { return "" }
+  set identityEnd [string first "?" $cleaned $identityStart]
+  if {$identityEnd < 0} { return "" }
+  return [string range $cleaned $identityStart [expr {$identityEnd - 1}]]
+}
+
+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 {\u276F[^\\r\\n]*(?:Exit|Cancel|Trust and install)} {
+    append dialogBuffer $expect_out(buffer)
+  }
+  -re {\u276F[^\\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 identity [extractPluginTrustIdentity $dialog]
+set compactIdentity [compactScreen $identity]
+if {$identity eq "" || $compactIdentity ne [compactScreen $installUrl]} {
+  set expectedRepoPrefix "[compactScreen $expectedRepo]/releases/tag/"
+  if {[string first $expectedRepoPrefix $compactIdentity] != 0} {
+    puts stderr "KIMI_TUI_STATE:plugin-trust:repo-mismatch"
+    exit 111
+  }
+  puts stderr "KIMI_TUI_STATE:plugin-trust:tag-mismatch"
+  exit 112
+}
+if {[regexp -nocase {(^|\\n)[^\\n]*\u276F[^\\n]*trust and install} $dialog]} {
+  send -- "\\033\\[13u"
+} elseif {[regexp -nocase {(^|\\n)[^\\n]*\u276F[^\\n]*(cancel|exit)} $dialog]} {
+  send -- "\\033\\[B"
+  expect {
+    -nocase -re {Trust this folder\\?} { directoryTrust }
+    -nocase -re {\u276F[^\\r\\n]*Trust and install} {}
+    -re {\u276F[^\\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
 `;
 }
 async function observeKimiTarget(target, kimiHome, run6) {
@@ -132338,7 +132577,7 @@ async function runKimiUpdate(target, detected, run6, kimiHome, {
     });
     return { status: "ALREADY_CURRENT", version: target.version };
   }
-  await withTemporaryWorkspace(async (workspace) => {
+  const tuiOutcome = await withTemporaryWorkspace(async (workspace) => {
     const checkout = join27(workspace.root, "plugin");
     await run6("git", [
       "clone",
@@ -132359,18 +132598,31 @@ async function runKimiUpdate(target, detected, run6, kimiHome, {
     }
     const installUrl = `https://github.com/${target.pluginRepo}/releases/tag/${target.pluginTag}`;
     const removePlugin = before.source === "legacy" ? target.plugin : "";
-    await run6(detected.expectCommand, ["-c", kimiExpectProgram({
-      ...removePlugin ? { removePlugin } : {}
-    })], {
-      timeout: 24e4,
-      env: {
-        ...env,
-        RELEASE_SKILL_KIMI_COMMAND: detected.command,
-        RELEASE_SKILL_KIMI_INSTALL_URL: installUrl,
-        RELEASE_SKILL_KIMI_REMOVE_PLUGIN: removePlugin
+    try {
+      await run6(detected.expectCommand, ["-c", kimiExpectProgram({
+        ...removePlugin ? { removePlugin } : {}
+      })], {
+        timeout: Math.max(3e5, 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, run6);
   if (!after.exact) throw new Error("Kimi did not report the frozen plugin identity after TUI installation");
   await verifyStructuredInstalledPayload({
@@ -132417,7 +132669,7 @@ async function updateLocalHostPluginsInternal({
   kimiHome,
   verifyInstalledPayload = verifyInstalledMarketplacePayload
 } = {}) {
-  const effectiveKimiHome = kimiHome ?? process.env.KIMI_CONFIG_DIR ?? join27(homedir(), ".kimi-code");
+  const effectiveKimiHome = kimiHome ?? process.env.KIMI_CODE_HOME ?? join27(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");
@@ -132506,7 +132758,7 @@ var init_post_release_local = __esm({
       "NODE_EXTRA_CA_CERTS",
       "CLAUDE_CONFIG_DIR",
       "CODEX_HOME",
-      "KIMI_CONFIG_DIR",
+      "KIMI_CODE_HOME",
       "CODEBUDDY_CONFIG_DIR",
       "WORKBUDDY_CONFIG_DIR"
     ]);
@@ -132539,6 +132791,8 @@ var init_post_release_local = __esm({
     __name(observeCodeBuddyMarketplaceAfterResidual, "observeCodeBuddyMarketplaceAfterResidual");
     __name(exactPluginObservation, "exactPluginObservation");
     __name(normalizeGitSource, "normalizeGitSource");
+    __name(parseFrozenRemoteRef, "parseFrozenRemoteRef");
+    __name(preflightStructuredMarketplace, "preflightStructuredMarketplace");
     __name(observeMarketplace, "observeMarketplace");
     __name(observeStructuredTarget, "observeStructuredTarget");
     __name(bindStructuredMarketplace, "bindStructuredMarketplace");
@@ -139872,8 +140126,7 @@ async function advanceShip(options = {}, injected = {}) {
   let postVerifyRanThisCall = false;
   if (state.status === "PUBLISHED" || state.status === "NEEDS_MANUAL_ATTESTATIONS") {
     const plan = JSON.parse(await readFile46(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);

package/adapters/workbuddy/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 "${CODEBUDDY_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 "${CODEBUDDY_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`。
 
 任何宿主失败都保留其他宿主的实际结果，不回滚，也不把失败冒充成功。