release-skill 0.2.3 → 0.2.5

package/src/commands/verify.mjs

@@ -12,8 +12,9 @@
  * @module commands/verify
  */
 
-import { readFile, writeFile, mkdtemp, rm, mkdir, lstat, realpath } from 'node:fs/promises';
-import { dirname, join, relative, isAbsolute, resolve } from 'node:path';
+import { readFile, writeFile, mkdtemp, rm, mkdir, lstat, realpath, readdir } from 'node:fs/promises';
+import { realpathSync } from 'node:fs';
+import { dirname, join, relative, isAbsolute, resolve, basename } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -50,11 +51,34 @@ import {
   resolveNpmRegistryAuthToken,
 } from '../adapters/npm.mjs';
 import { runConsumerVerificationGates } from '../core/verification-gates.mjs';
+import {
+  checkSkillResourceClosure,
+  createSkillResourceClosureReceipt,
+  evaluateConsumerSkillResourceClosureReceipts,
+} from '../core/skill-resource-closure.mjs';
+import { isRemoteWriteAction, isMarketplaceAction } from '../core/checkpoints.mjs';
+import {
+  shouldSkipVerification,
+  INSTALLATION_CONTRACT_ALGORITHM_VERSION,
+} from '../core/installation-contract.mjs';
 
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
 
+/**
+ * 验证已解决结果类型。
+ *
+ * - PASSED_AUTOMATIC: 自动验证通过（adapter.verify 返回 VERIFIED）
+ * - PASSED_MANUAL: 人工验证通过（用户手动确认）
+ * - NOT_REQUIRED_UNCHANGED: 无需验证（远端状态未变化，跳过验证）
+ */
+export const VERIFICATION_RESOLVED_TYPES = Object.freeze({
+  PASSED_AUTOMATIC: 'PASSED_AUTOMATIC',
+  PASSED_MANUAL: 'PASSED_MANUAL',
+  NOT_REQUIRED_UNCHANGED: 'NOT_REQUIRED_UNCHANGED',
+});
+
 /**
  * Map plan action type to adapter ActionType.
  * Must match publish.mjs and reconcile.mjs.
@@ -80,6 +104,16 @@ function defaultClock() {
   return new Date().toISOString();
 }
 
+/**
+ * 验证摘要格式是否为合法的 64 位十六进制字符串。
+ *
+ * @param {string} digest - 摘要
+ * @returns {boolean} 是否合法
+ */
+function isValidDigest(digest) {
+  return typeof digest === 'string' && /^[a-f0-9]{64}$/.test(digest);
+}
+
 // ---------------------------------------------------------------------------
 // Smoke test
 // ---------------------------------------------------------------------------
@@ -187,11 +221,13 @@ export async function runSmokeTest(plan, root, options = {}) {
         skipped: true,
         details: { message: 'No npm distributions in plan; smoke test skipped' },
         gateResults: [],
+        skillResourceClosureReceipts: [],
       };
     }
 
     const results = [];
     const gateResults = [];
+    const skillResourceClosureReceipts = [];
 
     for (const { package: pkgName, registry, targetVersion, unitId, smokeBin, smokeArgs, smokeExpectedJson } of npmDistributions) {
       const packageAtVersion = `${pkgName}@${targetVersion}`;
@@ -256,6 +292,47 @@ export async function runSmokeTest(plan, root, options = {}) {
       }
 
       const pkgRoot = join(installDir, 'node_modules', pkgName);
+      if (plan.skillResourceClosure) {
+        const expectedUnitReceipt = plan.skillResourceClosure.unitReceipts
+          .find((item) => item.unitId === unitId);
+        if (!expectedUnitReceipt) {
+          return {
+            passed: false,
+            details: { error: `Skill resource closure receipt missing for npm unit "${unitId}"` },
+          };
+        }
+        const closureResult = await checkSkillResourceClosure({
+          snapshotDir: pkgRoot,
+          host: 'npm',
+        });
+        if (closureResult.findings.length > 0) {
+          return {
+            passed: false,
+            details: {
+              error: `Skill resource closure failed for ${packageAtVersion}`,
+              findings: closureResult.findings,
+            },
+          };
+        }
+        if (expectedUnitReceipt.skillCount > 0 && closureResult.skillCount === 0) {
+          return {
+            passed: false,
+            details: {
+              error: `Installed npm package ${packageAtVersion} contains no skills`,
+            },
+          };
+        }
+        skillResourceClosureReceipts.push(createSkillResourceClosureReceipt(
+          closureResult,
+          {
+            unitId,
+            distribution: 'npm',
+            host: 'npm',
+            checkedAt: new Date().toISOString(),
+            exitCode: 0,
+          },
+        ));
+      }
       gateResults.push(...await runConsumerVerificationGates({
         plan,
         unitId,
@@ -442,6 +519,7 @@ export async function runSmokeTest(plan, root, options = {}) {
         count: results.length,
       },
       gateResults,
+      skillResourceClosureReceipts,
     };
   } finally {
     await rm(tmpDir, { recursive: true, force: true }).catch(() => {});
@@ -519,6 +597,7 @@ const defaultNpmExecutor = {
  * @param {string} [options.root] - Project root for source access.
  * @param {string} [options.runDir] - Evidence directory.
  * @param {() => string} [options.clock] - Clock function returning ISO-8601 strings.
+ * @param {Object} [options.previousVerifyRun] - 上一次验证成功的 verify run 记录，用于安装契约摘要免验。
  *
  * @returns {Promise<{ planPath: string, status: string, adapterChecks: Object[], smokeTest: Object }>}
  *
@@ -536,6 +615,7 @@ export async function verifyRelease(options) {
     npmExecutor,
     verificationGatesAuthorized,
     gateEnv,
+    previousVerifyRun,
   } = options ?? {};
 
   const clockFn = typeof clockOpt === 'function' ? clockOpt : defaultClock;
@@ -697,9 +777,13 @@ export async function verifyRelease(options) {
     // Validate checkpoint mapping
     validateRunCheckpointMapping(sourceRun, plan.externalActions ?? []);
 
-    // All checkpoints must be succeeded or skipped (no failed/pending)
+    // All checkpoints must be succeeded or skipped (no failed/pending),
+    // except marketplace install checkpoints which are re-verified by verify
+    // itself via consumer verification (human attestation or automatic).
+    // Deferred marketplace checkpoints from publish are also allowed through.
     const incompleteCheckpoints = sourceRun.checkpoints.filter(
-      (cp) => cp.status !== 'succeeded' && cp.status !== 'skipped',
+      (cp) => cp.status !== 'succeeded' && cp.status !== 'skipped'
+        && !((cp.status === 'failed' || cp.status === 'deferred') && isMarketplaceAction(cp.actionType)),
     );
     if (incompleteCheckpoints.length > 0) {
       throw new ReleaseError(
@@ -731,13 +815,130 @@ export async function verifyRelease(options) {
 
     const adapterChecks = [];
     const consumerGateResults = [];
+    const consumerVerificationReceipts = [];
     const actions = plan.externalActions ?? [];
-    const MARKETPLACE_TYPES = new Set([
-      'claude-marketplace-install',
-      'codex-marketplace-install',
-      'kimi-marketplace-install',
-      'codebuddy-marketplace-install',
-    ]);
+
+    // --- 自动发现可信消费端验证收据 ---
+    // 收据选择逻辑（per-action 从所有候选中选最新匹配）：
+    // - 只读取同一权威 .release-skill/runs 的真实直接子目录
+    // - runs 根或候选目录不得是符号链接，不得物理越界
+    // - 候选必须经 loadRun(..., { requireDigest: true })、状态 VERIFIED、合法 finishedAt
+    // - 对当前 action 收集所有可信匹配收据，按 finishedAt 最新选择
+    // - 收据必须是 consumerVerificationReceipts，严格匹配 actionId/unitId/platform
+    // - 收据 planDigest 等于候选 run 自身 planDigest
+    // - 显式注入的 previousVerifyRun 也必须经过同等语义校验
+
+    /** @type {Array<Object>} 所有可信的验证 run 候选 */
+    const trustedVerifyRuns = [];
+
+    // 计算权威 runs 目录路径（基于 plan 的物理位置）
+    const planDir = dirname(planPath);
+    const releaseDir = basename(planDir) === 'plans' ? dirname(planDir) : planDir;
+    const runsDir = resolve(releaseDir, 'runs');
+    let runsDirReal = null;
+    let authorityDirReal = null;
+
+    // 校验并纳入显式注入的 previousVerifyRun
+    // 必须经过完整语义校验：status=VERIFIED、合法 runDigest、合法 finishedAt、
+    // 合法 planDigest、收据身份绑定。不满足则不注入（不参与复用），但不阻断。
+    if (previousVerifyRun) {
+      if (
+        previousVerifyRun.status === 'VERIFIED'
+        && isValidDigest(previousVerifyRun.planDigest)
+        && previousVerifyRun.finishedAt
+        && typeof previousVerifyRun.finishedAt === 'string'
+        && !isNaN(Date.parse(previousVerifyRun.finishedAt))
+      ) {
+        const computedRunDigest = computeRunDigest(previousVerifyRun);
+        if (
+          typeof previousVerifyRun.runDigest === 'string'
+          && previousVerifyRun.runDigest.length > 0
+          && previousVerifyRun.runDigest === computedRunDigest
+        ) {
+          trustedVerifyRuns.push(previousVerifyRun);
+        }
+      }
+    }
+
+    // 自动发现：从同一 .release-skill/runs 权威目录中发现
+    {
+      try {
+        const runsDirStat = await lstat(runsDir);
+        if (runsDirStat.isSymbolicLink()) {
+          // runs 根是符号链接：权威目录身份错误，失败关闭
+          throw new ReleaseError(
+            GATE_FAILED,
+            'runs directory is a symbolic link; authority identity compromised',
+            { runsDir },
+          );
+        }
+        if (!runsDirStat.isDirectory()) {
+          throw new ReleaseError(
+            GATE_FAILED,
+            'runs path is not a directory',
+            { runsDir },
+          );
+        }
+        // 以 plan 的物理权威目录为基准，验证 runs 是其中真实 runs 子目录
+        runsDirReal = realpathSync(runsDir);
+        authorityDirReal = realpathSync(releaseDir);
+        if (!runsDirReal.startsWith(authorityDirReal + '/') && runsDirReal !== authorityDirReal) {
+          throw new ReleaseError(
+            GATE_FAILED,
+            'runs directory is not a real child of the plan authority directory',
+            { runsDir, runsDirReal, authorityDirReal },
+          );
+        }
+      } catch (err) {
+        if (err instanceof ReleaseError) throw err;
+        // runs 目录不存在等非致命情况：跳过自动发现
+        runsDirReal = null;
+      }
+
+      if (runsDirReal) {
+        const entries = await readdir(runsDirReal, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.name.startsWith('verify-')) continue;
+          // 非目录或符号链接：失败关闭
+          if (!entry.isDirectory() || entry.isSymbolicLink()) {
+            throw new ReleaseError(
+              GATE_FAILED,
+              'verify-* candidate is a symbolic link or not a directory; authority identity compromised',
+              { entry: entry.name, runsDir: runsDirReal },
+            );
+          }
+          const candidateDir = resolve(runsDirReal, entry.name);
+          const candidateStat = await lstat(candidateDir).catch(() => null);
+          if (!candidateStat || candidateStat.isSymbolicLink()) {
+            throw new ReleaseError(
+              GATE_FAILED,
+              'verify-* candidate is a symbolic link; authority identity compromised',
+              { candidateDir, runsDir: runsDirReal },
+            );
+          }
+          // realpath 包含性校验：候选必须在权威 runs 目录内
+          const candidateReal = realpathSync(candidateDir);
+          if (!candidateReal.startsWith(runsDirReal + '/') && candidateReal !== runsDirReal) {
+            throw new ReleaseError(
+              GATE_FAILED,
+              'verify-* candidate real path is not contained in authority runs directory',
+              { candidateDir, candidateReal, runsDir: runsDirReal },
+            );
+          }
+          const candidatePath = resolve(candidateDir, 'release-run.json');
+          try {
+            const candidate = await loadRun(candidatePath, { requireDigest: true });
+            if (candidate.status !== 'VERIFIED') continue;
+            if (!candidate.planDigest) continue;
+            if (!candidate.finishedAt || typeof candidate.finishedAt !== 'string') continue;
+            trustedVerifyRuns.push(candidate);
+          } catch {
+            // 真实直接目录里的坏/缺 release-run.json 可忽略
+            continue;
+          }
+        }
+      }
+    }
 
     for (const action of actions) {
       const adapterActionType = ADAPTER_ACTION_TYPE_MAP[action.type];
@@ -765,7 +966,7 @@ export async function verifyRelease(options) {
         );
       }
 
-      if (MARKETPLACE_TYPES.has(action.type)) {
+      if (isMarketplaceAction(action.type)) {
         // --- Marketplace: fresh consumer verification in verify's own runDir ---
         // Context: isolatedConsumerWritesAuthorized allows writing to verify's
         // runDir/consumers/ directory; externalWritesAuthorized stays false.
@@ -783,22 +984,108 @@ export async function verifyRelease(options) {
           ...action.parameters,
         };
 
-        // Step 3a: Preflight (validate frozen snapshot, parameters)
+        // --- 安装契约摘要免验检查 ---
+        // 从计划中读取冻结的安装契约摘要。
+        // 新计划在 prepare 阶段计算并冻结 installationContractDigest；
+        // 旧计划（无此字段）跳过免验检查，强制重新验证。
+        const unit = (plan.units ?? []).find((u) => u.id === action.unitId);
+        const typeToDist = {
+          'claude-marketplace-install': 'claude-plugin',
+          'codex-marketplace-install': 'codex-plugin',
+          'kimi-marketplace-install': 'kimi-plugin',
+          'codebuddy-marketplace-install': 'codebuddy-plugin',
+        };
+        const dist = unit?.distributions?.find((d) => d.type === typeToDist[action.type]);
+
+        // Step 3a: Preflight（始终先执行 adapter preflight，完成静态身份、版本、
+        // tag/ref/sha、来源和 payload 校验；只有 preflight 通过后才允许免验）
+        // 必须明确要求 PREFLIGHT_PASSED，其他状态全部失败关闭。
         const preflightResult = await adapter.preflight(actionInput, marketplaceContext);
-        if (preflightResult.status === 'PREFLIGHT_FAILED') {
+        if (preflightResult.status !== 'PREFLIGHT_PASSED') {
           adapterChecks.push({
             actionId: action.id,
             actionType: action.type,
             status: 'FAILED',
-            error: `preflight failed: ${preflightResult.error}`,
+            error: `preflight did not pass: status=${preflightResult.status}, error=${preflightResult.error}`,
           });
           throw new ReleaseError(
             POST_PUBLISH_VERIFY_FAILED,
-            `marketplace preflight failed for action "${action.id}": ${preflightResult.error}`,
+            `marketplace preflight did not pass for action "${action.id}": status=${preflightResult.status}, error=${preflightResult.error}`,
             { actionId: action.id },
           );
         }
 
+        // Preflight 通过后，检查是否可以免验
+        if (dist?.installationContractDigest) {
+          const currentDigest = dist.installationContractDigest;
+          const currentPlatform = action.parameters?.consumer ?? action.type.replace('-marketplace-install', '');
+
+          // 紧邻可信公开基线：只检查最近一个 VERIFIED run 的收据。
+          // 不能从任意更老历史中捞出相同摘要来免验。
+          // 若最近 run 无该 action/platform 的收据，则 REQUIRE_VERIFICATION。
+          let previousActionCheck = null;
+          if (trustedVerifyRuns.length > 0) {
+            // 按 finishedAt 降序排序，取最近一个
+            const sorted = [...trustedVerifyRuns].sort((a, b) => {
+              const ta = Date.parse(a.finishedAt) || 0;
+              const tb = Date.parse(b.finishedAt) || 0;
+              return tb - ta;
+            });
+            const latest = sorted[0];
+            const matchingReceipt = (latest.consumerVerificationReceipts ?? []).find(
+              (r) => r.actionId === action.id
+                && r.unitId === action.unitId
+                && r.platform === currentPlatform
+                && r.planDigest === latest.planDigest,
+            );
+            if (matchingReceipt) {
+              previousActionCheck = { ...matchingReceipt, _runFinishedAtTime: Date.parse(latest.finishedAt) };
+            }
+          }
+          const previousDigest = previousActionCheck?.installationContractDigest ?? null;
+
+          const skipDecision = shouldSkipVerification({
+            currentDigest,
+            previousDigest,
+            previousReceipt: previousActionCheck,
+            algorithmVersion: INSTALLATION_CONTRACT_ALGORITHM_VERSION,
+          });
+
+          // A current-run resource-closure receipt requires a fresh isolated
+          // install. Installation-contract reuse alone cannot prove the
+          // installed Skill resources are reachable.
+          if (skipDecision === 'NOT_REQUIRED_UNCHANGED' && !plan.skillResourceClosure) {
+            adapterChecks.push({
+              actionId: action.id,
+              actionType: action.type,
+              status: VERIFICATION_RESOLVED_TYPES.NOT_REQUIRED_UNCHANGED,
+              installationContractDigest: currentDigest,
+              reason: '安装契约摘要未变化，跳过验证',
+            });
+
+            consumerVerificationReceipts.push({
+              actionId: action.id,
+              unitId: action.unitId,
+              platform: action.parameters?.consumer ?? action.type.replace('-marketplace-install', ''),
+              result: VERIFICATION_RESOLVED_TYPES.NOT_REQUIRED_UNCHANGED,
+              installationContractDigest: currentDigest,
+              algorithmVersion: INSTALLATION_CONTRACT_ALGORITHM_VERSION,
+              planDigest: plan.digest,
+              verifiedAt: clockFn(),
+            });
+
+            await evidence.append({
+              phase: 'verify-marketplace',
+              actionId: action.id,
+              actionType: action.type,
+              status: VERIFICATION_RESOLVED_TYPES.NOT_REQUIRED_UNCHANGED,
+              installationContractDigest: currentDigest,
+            });
+
+            continue;
+          }
+        }
+
         // Step 3b: Execute (install to isolated consumer directory)
         const executeResult = await adapter.execute(actionInput, marketplaceContext);
         if (executeResult.status !== 'EXECUTED') {
@@ -821,15 +1108,39 @@ export async function verifyRelease(options) {
           marketplaceContext,
         );
 
+        // 正确分类：人工确认 -> PASSED_MANUAL，其他自动通路 -> PASSED_AUTOMATIC
+        const isHumanConfirmed = verifyResult.observation?.humanConfirmed === true;
+        const resolvedStatus = verifyResult.status === 'VERIFIED'
+          ? (isHumanConfirmed
+            ? VERIFICATION_RESOLVED_TYPES.PASSED_MANUAL
+            : VERIFICATION_RESOLVED_TYPES.PASSED_AUTOMATIC)
+          : 'FAILED';
+
         const check = {
           actionId: action.id,
           actionType: action.type,
-          status: verifyResult.status === 'VERIFIED' ? 'PASSED' : 'FAILED',
+          status: resolvedStatus,
           observation: verifyResult.observation,
           error: verifyResult.error,
+          ...(dist?.installationContractDigest ? { installationContractDigest: dist.installationContractDigest } : {}),
         };
         adapterChecks.push(check);
 
+        // 持久化消费端验证收据
+        // 旧计划无摘要时可不生成"安装契约复用收据"，但不得写非法空字符串
+        if (resolvedStatus !== 'FAILED' && dist?.installationContractDigest && /^[a-f0-9]{64}$/.test(dist.installationContractDigest)) {
+          consumerVerificationReceipts.push({
+            actionId: action.id,
+            unitId: action.unitId,
+            platform: action.parameters?.consumer ?? action.type.replace('-marketplace-install', ''),
+            result: resolvedStatus,
+            installationContractDigest: dist.installationContractDigest,
+            algorithmVersion: INSTALLATION_CONTRACT_ALGORITHM_VERSION,
+            planDigest: plan.digest,
+            verifiedAt: clockFn(),
+          });
+        }
+
         await evidence.append({
           phase: 'verify-marketplace',
           actionId: action.id,
@@ -841,7 +1152,13 @@ export async function verifyRelease(options) {
           throw new ReleaseError(
             POST_PUBLISH_VERIFY_FAILED,
             `marketplace verification failed for action "${action.id}": ${verifyResult.error}`,
-            { actionId: action.id, observation: verifyResult.observation },
+            {
+              actionId: action.id,
+              actionType: action.type,
+              verificationResult: check.status,
+              observation: verifyResult.observation,
+              expected: action.expected,
+            },
           );
         }
 
@@ -901,7 +1218,7 @@ export async function verifyRelease(options) {
         const check = {
           actionId: action.id,
           actionType: action.type,
-          status: verifyResult.status === 'VERIFIED' ? 'PASSED' : 'FAILED',
+          status: verifyResult.status === 'VERIFIED' ? VERIFICATION_RESOLVED_TYPES.PASSED_AUTOMATIC : 'FAILED',
           observation: verifyResult.observation,
           error: verifyResult.error,
         };
@@ -919,7 +1236,13 @@ export async function verifyRelease(options) {
           throw new ReleaseError(
             POST_PUBLISH_VERIFY_FAILED,
             `adapter verification failed for action "${action.id}": ${verifyResult.error}`,
-            { actionId: action.id, observation: verifyResult.observation },
+            {
+              actionId: action.id,
+              actionType: action.type,
+              verificationResult: check.status,
+              observation: verifyResult.observation,
+              expected: action.expected,
+            },
           );
         }
       }
@@ -970,6 +1293,103 @@ export async function verifyRelease(options) {
       );
     }
 
+    // =======================================================================
+    // Step 4b: Skill resource closure check on consumer install surfaces
+    // Re-run the closure check on each declared consumer install surface.
+    // If the plan declares skillResourceClosure, every declared host surface
+    // must be checked and pass; undeclared or failed surfaces block VERIFIED.
+    // =======================================================================
+    const skillResourceClosureReceipts = [
+      ...(smokeTest.skillResourceClosureReceipts ?? []),
+    ];
+    if (plan.skillResourceClosure) {
+      await evidence.append({ phase: 'verify', step: 'skill-resource-closure', status: 'started' });
+
+      // Collect install paths from marketplace adapter checks
+      const installSurfaces = [];
+      const actionDistribution = {
+        'claude-marketplace-install': 'claude-plugin',
+        'codex-marketplace-install': 'codex-plugin',
+        'kimi-marketplace-install': 'kimi-plugin',
+        'codebuddy-marketplace-install': 'codebuddy-plugin',
+      };
+      for (const check of adapterChecks) {
+        const distribution = actionDistribution[check.actionType];
+        if (distribution && check.observation?.installPath) {
+          installSurfaces.push({
+            host: distribution.replace('-plugin', ''),
+            distribution,
+            installPath: check.observation.installPath,
+            actionId: check.actionId,
+            unitId: actions.find((a) => a.id === check.actionId)?.unitId,
+          });
+        }
+      }
+
+      for (const surface of installSurfaces) {
+        const closureResult = await checkSkillResourceClosure({
+          snapshotDir: surface.installPath,
+          host: surface.host,
+        });
+
+        if (closureResult.findings.length > 0) {
+          await evidence.append({
+            phase: 'verify',
+            step: 'skill-resource-closure',
+            status: 'failed',
+            host: surface.host,
+            findingCount: closureResult.findings.length,
+            findings: closureResult.findings,
+          });
+          throw new ReleaseError(
+            POST_PUBLISH_VERIFY_FAILED,
+            `skill resource closure check failed for ${surface.host} consumer install: ${closureResult.findings.length} finding(s)`,
+            { host: surface.host, findings: closureResult.findings },
+          );
+        }
+        const expectedUnitReceipt = plan.skillResourceClosure.unitReceipts
+          .find((item) => item.unitId === surface.unitId);
+        if (!expectedUnitReceipt || closureResult.skillCount === 0) {
+          throw new ReleaseError(
+            POST_PUBLISH_VERIFY_FAILED,
+            `skill resource closure installed surface is empty or unbound for ${surface.distribution}`,
+            { unitId: surface.unitId, distribution: surface.distribution },
+          );
+        }
+        skillResourceClosureReceipts.push(createSkillResourceClosureReceipt(
+          closureResult,
+          {
+            host: surface.host,
+            distribution: surface.distribution,
+            actionId: surface.actionId,
+            unitId: surface.unitId,
+            checkedAt: clockFn(),
+            exitCode: 0,
+          },
+        ));
+      }
+
+      const receiptCoverage = evaluateConsumerSkillResourceClosureReceipts(
+        plan,
+        skillResourceClosureReceipts,
+      );
+      if (!receiptCoverage.passed) {
+        throw new ReleaseError(
+          POST_PUBLISH_VERIFY_FAILED,
+          'skill resource closure receipt set does not match declared consumer distributions',
+          receiptCoverage,
+        );
+      }
+
+      await evidence.append({
+        phase: 'verify',
+        step: 'skill-resource-closure',
+        status: 'completed',
+        surfaceCount: installSurfaces.length,
+        receipts: skillResourceClosureReceipts,
+      });
+    }
+
     // =======================================================================
     // All verifications passed — write verify run
     // =======================================================================
@@ -994,13 +1414,27 @@ export async function verifyRelease(options) {
       status: VERIFIED,
       checkpoints: actions.map((a) => {
         const check = adapterChecks.find((c) => c.actionId === a.id);
+        let status;
+        if (check?.status === 'SKIPPED') {
+          status = 'skipped';
+        } else if (check?.status === VERIFICATION_RESOLVED_TYPES.PASSED_AUTOMATIC) {
+          status = 'succeeded';
+        } else if (check?.status === VERIFICATION_RESOLVED_TYPES.PASSED_MANUAL) {
+          status = 'succeeded';
+        } else if (check?.status === VERIFICATION_RESOLVED_TYPES.NOT_REQUIRED_UNCHANGED) {
+          status = 'skipped';
+        } else {
+          status = 'succeeded';
+        }
         return {
           actionId: a.id,
           actionType: a.type,
-          status: check?.status === 'SKIPPED' ? 'skipped' : 'succeeded',
+          status,
         };
       }),
       gateResults: consumerGateResults,
+      consumerVerificationReceipts,
+      skillResourceClosureReceipts,
       startedAt: clockFn(),
       finishedAt: clockFn(),
     };

package/src/core/baseline.mjs

@@ -172,12 +172,19 @@ async function computeWorkspaceDigest(root) {
 
   // Ask Git for unambiguous NUL-delimited names, then request the patch for
   // each exact argv path. This avoids parsing C-quoted `diff --git` headers.
+  //
+  // Per-file `git diff --binary` can exceed Node.js default ~1 MiB maxBuffer
+  // when generated bundles (e.g. 3.8 MiB) are modified. We use an explicit
+  // 64 MiB upper bound: large enough for any realistic single-file diff, small
+  // enough to fail closed before exhausting memory.
+  const DIFF_MAX_BUFFER = 64 * 1024 * 1024; // 64 MiB
+  const diffOpts = { ...opts, maxBuffer: DIFF_MAX_BUFFER };
   const changedPaths = splitNul(changedOut).filter((p) => !isControlPlanePath(p));
   for (const changedPath of changedPaths) {
     const { stdout: patch } = await execFile(
       'git',
       ['diff', '--no-ext-diff', '--no-textconv', '--binary', '--no-color', '--', changedPath],
-      opts,
+      diffOpts,
     );
     parts.push(`UNSTAGED:${changedPath}\0${patch}`);
   }