release-skill 0.2.4 → 0.2.5

package/package.json

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

package/schemas/release-plan.schema.json

@@ -815,6 +815,97 @@
       "minLength": 1,
       "description": "Digest of the project configuration at plan freeze time"
     },
+    "skillResourceClosure": {
+      "type": "object",
+      "description": "Skill resource closure gate receipts from prepare phase (per-unit bound)",
+      "additionalProperties": false,
+      "properties": {
+        "unitReceipts": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "unitId": {
+                "type": "string",
+                "minLength": 1
+              },
+              "checkerVersion": {
+                "type": "string",
+                "minLength": 1
+              },
+              "inputDigest": {
+                "type": "string",
+                "pattern": "^[a-f0-9]{64}$"
+              },
+              "surfaceCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "skillCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "referenceCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "sourceOnlyCount": {
+                "type": "integer",
+                "minimum": 0
+              },
+              "findingCount": {
+                "const": 0
+              },
+              "receiptDigest": {
+                "type": "string",
+                "pattern": "^[a-f0-9]{64}$"
+              }
+            },
+            "required": [
+              "unitId",
+              "checkerVersion",
+              "inputDigest",
+              "surfaceCount",
+              "skillCount",
+              "referenceCount",
+              "sourceOnlyCount",
+              "findingCount",
+              "receiptDigest"
+            ]
+          }
+        },
+        "checkerVersion": {
+          "type": "string",
+          "minLength": 1
+        },
+        "totalSkillCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "totalReferenceCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "totalSourceOnlyCount": {
+          "type": "integer",
+          "minimum": 0
+        },
+        "totalFindingCount": {
+          "type": "integer",
+          "minimum": 0
+        }
+      },
+      "required": [
+        "unitReceipts",
+        "checkerVersion",
+        "totalSkillCount",
+        "totalReferenceCount",
+        "totalSourceOnlyCount",
+        "totalFindingCount"
+      ]
+    },
     "verificationGates": {
       "type": "array",
       "items": {

package/schemas/release-run.schema.json

@@ -366,6 +366,91 @@
           }
         }
       }
+    },
+    "skillResourceClosureReceipts": {
+      "type": "array",
+      "description": "Per-surface skill resource closure verification receipts from verify phase",
+      "items": {
+        "type": "object",
+        "required": [
+          "host",
+          "distribution",
+          "unitId",
+          "checkerVersion",
+          "inputDigest",
+          "surfaceCount",
+          "skillCount",
+          "referenceCount",
+          "sourceOnlyCount",
+          "findingCount",
+          "receiptDigest",
+          "checkedAt",
+          "exitCode"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "host": {
+            "type": "string",
+            "minLength": 1
+          },
+          "unitId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "distribution": {
+            "type": "string",
+            "enum": [
+              "npm",
+              "claude-plugin",
+              "codex-plugin",
+              "kimi-plugin",
+              "codebuddy-plugin"
+            ]
+          },
+          "actionId": {
+            "type": "string",
+            "minLength": 1
+          },
+          "checkerVersion": {
+            "type": "string",
+            "minLength": 1
+          },
+          "inputDigest": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+          },
+          "surfaceCount": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "skillCount": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "referenceCount": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "sourceOnlyCount": {
+            "type": "integer",
+            "minimum": 0
+          },
+          "findingCount": {
+            "const": 0
+          },
+          "receiptDigest": {
+            "type": "string",
+            "pattern": "^[a-f0-9]{64}$"
+          },
+          "checkedAt": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "exitCode": {
+            "const": 0
+          }
+        }
+      }
     }
   },
   "allOf": [

package/scripts/sync-public-files.mjs

@@ -208,9 +208,9 @@ function buildRequiredPublicFilesYaml(entries, indent = 6) {
 // Entry collection
 // ---------------------------------------------------------------------------
 
-async function collectEntries() {
+async function collectEntries(packageRoot) {
   // 1. Scan all files in the package directory
-  const allFiles = await scanFiles(PKG_ROOT);
+  const allFiles = await scanFiles(packageRoot);
   const allSet = new Set(allFiles);
 
   // 2. Build the adapter exclusion set (all files under adapters/)
@@ -303,8 +303,8 @@ async function collectEntries() {
 // Check / write
 // ---------------------------------------------------------------------------
 
-async function readProjectYaml() {
-  return await readFile(PROJECT_YAML, 'utf8');
+async function readProjectYaml(projectPath) {
+  return await readFile(projectPath, 'utf8');
 }
 
 function extractExistingEntries(yamlText, key) {
@@ -369,18 +369,29 @@ function replaceArrayInYaml(yamlText, key, newContent) {
  *
  * @param {object} options
  * @param {string} options.packageDir - Package directory.
+ * @param {string} [options.projectPath] - Project config path. Defaults to the
+ * real workspace config; tests may provide an isolated copy.
  * @param {boolean} [options.check] - Read-only drift detection.
  * @returns {Promise<{mode: string, clean?: boolean, diff?: object}>}
  */
-export async function syncPublicFiles({ packageDir, check = false } = {}) {
+export async function syncPublicFiles({
+  packageDir,
+  projectPath = PROJECT_YAML,
+  check = false,
+} = {}) {
   if (typeof packageDir !== 'string' || packageDir.length === 0) {
     const err = new Error('sync-public-files: packageDir is required');
     err.code = 'SYNC_PUBLIC_FILES_INVALID_ARGUMENT';
     throw err;
   }
+  if (typeof projectPath !== 'string' || projectPath.length === 0) {
+    const err = new Error('sync-public-files: projectPath must be a non-empty string');
+    err.code = 'SYNC_PUBLIC_FILES_INVALID_ARGUMENT';
+    throw err;
+  }
 
-  const entries = await collectEntries();
-  const yamlText = await readProjectYaml();
+  const entries = await collectEntries(packageDir);
+  const yamlText = await readProjectYaml(projectPath);
 
   const existingPublic = extractExistingEntries(yamlText, 'publicFiles');
   const existingRequired = extractExistingEntries(yamlText, 'requiredPublicFiles');
@@ -422,10 +433,10 @@ export async function syncPublicFiles({ packageDir, check = false } = {}) {
   let newYaml = replaceArrayInYaml(yamlText, 'publicFiles', publicYaml);
   newYaml = replaceArrayInYaml(newYaml, 'requiredPublicFiles', requiredYaml);
 
-  await writeFile(PROJECT_YAML, newYaml, 'utf8');
+  await writeFile(projectPath, newYaml, 'utf8');
 
   // Verify write
-  const reread = await readFile(PROJECT_YAML, 'utf8');
+  const reread = await readFile(projectPath, 'utf8');
   if (reread !== newYaml) {
     const err = new Error('sync-public-files: post-write verification failed');
     err.code = 'SYNC_PUBLIC_FILES_WRITE_VERIFY_FAILED';

package/src/adapters/plugin-marketplace.mjs

@@ -2882,6 +2882,7 @@ export function createPluginMarketplaceAdapter(deps = {}) {
 
             // 使用归一化后的 attestation（兼容旧格式）
             const normalizedAttestation = attestationCheck.normalized;
+            const requiresInstalledClosure = Boolean(context.plan?.skillResourceClosure);
 
             // 统一人工判定：如果结果是 failed，直接返回失败
             if (normalizedAttestation.result === 'failed') {
@@ -2901,7 +2902,19 @@ export function createPluginMarketplaceAdapter(deps = {}) {
               });
             }
 
+            if (requiresInstalledClosure && !normalizedAttestation.installPath) {
+              return createResult({
+                actionType,
+                status: ActionStatus.OBSERVED,
+                observation: {
+                  installed: false,
+                  error: 'kimi attestation installPath is required by the skill resource closure gate',
+                },
+              });
+            }
+
             // installPath 验证：必须在 managed root 内，不得逃逸，不得是符号链接
+            let verifiedInstallPath = null;
             if (normalizedAttestation.installPath) {
               const managedRoot = resolve(attestationDir, 'kimi-home', 'plugins', 'managed');
               const installPathAbs = resolve(normalizedAttestation.installPath);
@@ -2967,18 +2980,19 @@ export function createPluginMarketplaceAdapter(deps = {}) {
                   },
                 });
               }
+              verifiedInstallPath = installPathReal;
             }
 
             // 载荷绑定验证：旧格式含 installPath 时必须绑定冻结载荷并失败关闭。
             // 身份、版本、载荷、市场来源不一致绝不能被人工 passed 覆盖。
             let manifestDigest = action.manifestDigest;
             let payloadBinding = null;
-            if (normalizedAttestation.installPath) {
+            if (verifiedInstallPath) {
               try {
                 payloadBinding = await verifyInstalledMarketplacePayload(
                   action,
                   context,
-                  normalizedAttestation.installPath,
+                  verifiedInstallPath,
                   consumer,
                 );
                 manifestDigest = payloadBinding.manifestDigest;
@@ -3019,6 +3033,7 @@ export function createPluginMarketplaceAdapter(deps = {}) {
                 entrySkillFound: true,
                 manifestDigest,
                 planDigest: boundPlanDigest,
+                ...(verifiedInstallPath ? { installPath: verifiedInstallPath } : {}),
                 ...extraInstalledPathsAudit(payloadBinding),
               },
             });
@@ -3129,6 +3144,7 @@ export function createPluginMarketplaceAdapter(deps = {}) {
 
             // 使用归一化后的 attestation（兼容旧格式）
             const normalizedAttestation = attestationCheck.normalized;
+            const requiresInstalledClosure = Boolean(context.plan?.skillResourceClosure);
 
             // 统一人工判定：如果结果是 failed，直接返回失败
             if (normalizedAttestation.result === 'failed') {
@@ -3148,7 +3164,69 @@ export function createPluginMarketplaceAdapter(deps = {}) {
               });
             }
 
-            // 统一人工判定：返回人工确认成功（不再进行自动化验证）
+            let verifiedInstallPath = null;
+            if (requiresInstalledClosure) {
+              if (!normalizedAttestation.installPath) {
+                return createResult({
+                  actionType,
+                  status: ActionStatus.OBSERVED,
+                  observation: {
+                    installed: false,
+                    error: 'codebuddy attestation installPath is required by the skill resource closure gate',
+                  },
+                });
+              }
+              if (!['desktop', 'cli'].includes(normalizedAttestation.installChannel)) {
+                return createResult({
+                  actionType,
+                  status: ActionStatus.OBSERVED,
+                  observation: {
+                    installed: false,
+                    error: 'codebuddy attestation installChannel must be "desktop" or "cli" when the skill resource closure gate is active',
+                  },
+                });
+              }
+              const normalizedPath = normalizedAttestation.installPath.replaceAll('\\', '/');
+              const expectedSuffix = `.workbuddy/plugins/marketplaces/${CODEBUDDY_MARKETPLACE_NAME}/plugins/${action.plugin}`;
+              if (!normalizedPath.endsWith(expectedSuffix)) {
+                return createResult({
+                  actionType,
+                  status: ActionStatus.OBSERVED,
+                  observation: {
+                    installed: false,
+                    error: `codebuddy attestation installPath must end with "${expectedSuffix}"`,
+                  },
+                });
+              }
+              const installPathAbs = resolve(normalizedAttestation.installPath);
+              let lexicalStat;
+              try {
+                lexicalStat = await lstat(installPathAbs);
+              } catch {
+                return createResult({
+                  actionType,
+                  status: ActionStatus.OBSERVED,
+                  observation: {
+                    installed: false,
+                    error: `codebuddy attestation installPath does not exist: ${normalizedAttestation.installPath}`,
+                  },
+                });
+              }
+              if (lexicalStat.isSymbolicLink() || !lexicalStat.isDirectory()) {
+                return createResult({
+                  actionType,
+                  status: ActionStatus.OBSERVED,
+                  observation: {
+                    installed: false,
+                    error: 'codebuddy attestation installPath must be a real directory, not a symlink',
+                  },
+                });
+              }
+              verifiedInstallPath = await realpath(installPathAbs);
+            }
+
+            // 人工结果仍裁决不可自动化的安装步骤；新资源闭包计划另外
+            // 暴露已校验的真实安装目录，供 verify 的内置只读门禁扫描。
             return createResult({
               actionType,
               status: ActionStatus.OBSERVED,
@@ -3167,6 +3245,7 @@ export function createPluginMarketplaceAdapter(deps = {}) {
                 entrySkillFound: true,
                 manifestDigest: action.manifestDigest,
                 planDigest: boundPlanDigest,
+                ...(verifiedInstallPath ? { installPath: verifiedInstallPath } : {}),
               },
             });
           }

package/src/commands/prepare.mjs

@@ -33,6 +33,11 @@ import { runSnapshotVerificationGates } from '../core/verification-gates.mjs';
 import { createEvidenceWriter } from '../core/evidence.mjs';
 import { computePlanDigest, writePlanAtomic, writePlanImmutable } from '../core/plan.mjs';
 import { sha256Hex } from '../core/digest.mjs';
+import {
+  CHECKER_VERSION as SKILL_RESOURCE_CHECKER_VERSION,
+  checkSkillResourceClosure,
+  createSkillResourceClosureReceipt,
+} from '../core/skill-resource-closure.mjs';
 import { buildPublicStaging } from '../snapshot/public-map.mjs';
 import { resolveUnitScopedPath } from '../snapshot/public-path.mjs';
 import { scanSnapshot } from '../snapshot/scan.mjs';
@@ -2234,6 +2239,67 @@ export async function prepareRelease(options) {
         )
       : null;
 
+    // --- Step 7b: Skill resource closure gate ---
+    // Production snapshots are sealed inside buildProductionAssets. Scan only
+    // after that transition so the receipt binds the exact byte/mode identity
+    // publish will re-verify, rather than the writable pre-freeze staging tree.
+    // Non-production plans scan the final staging tree at the same point.
+    // This gate is built in, read-only, and cannot be disabled by overlays.
+    const skillResourceClosureResults = [];
+    for (const { unit, manifest } of unitResults) {
+      await evidence.append({
+        phase: 'skill-resource-closure',
+        status: 'started',
+        unitId: unit.id,
+      });
+
+      const closureResult = await checkSkillResourceClosure({
+        snapshotDir: manifest.outputDir,
+        host: 'root',
+      });
+
+      const receipt = createSkillResourceClosureReceipt(closureResult, { unitId: unit.id });
+      skillResourceClosureResults.push(receipt);
+
+      if (closureResult.findings.length > 0) {
+        await evidence.append({
+          phase: 'skill-resource-closure',
+          status: 'blocking',
+          unitId: unit.id,
+          findingCount: closureResult.findings.length,
+          findings: closureResult.findings.map((f) => ({
+            skill: f.skill,
+            line: f.line,
+            reference: f.reference,
+            classification: f.classification,
+            code: f.code,
+          })),
+        });
+        throw new ReleaseError(
+          GATE_FAILED,
+          `skill resource closure gate failed for unit "${unit.id}": ${closureResult.findings.length} finding(s)`,
+          {
+            unitId: unit.id,
+            findingCount: closureResult.findings.length,
+            findings: closureResult.findings,
+          },
+        );
+      }
+
+      await evidence.append({
+        phase: 'skill-resource-closure',
+        status: 'completed',
+        unitId: unit.id,
+        checkerVersion: closureResult.checkerVersion,
+        surfaceCount: receipt.surfaceCount,
+        skillCount: receipt.skillCount,
+        referenceCount: closureResult.referenceCount,
+        sourceOnlyCount: closureResult.sourceOnlyCount,
+        findingCount: 0,
+        receiptDigest: closureResult.receiptDigest,
+      });
+    }
+
     // Freeze external independent marketplace HEADs (production + online only):
     // for each claude/codex/codebuddy distribution declaring marketplaceRepo,
     // resolve the external repo's HEAD sha + default branch and validate the
@@ -2581,6 +2647,14 @@ export async function prepareRelease(options) {
         capturedAt: baseline.capturedAt,
       },
       configDigest,
+      skillResourceClosure: {
+        checkerVersion: SKILL_RESOURCE_CHECKER_VERSION,
+        unitReceipts: skillResourceClosureResults,
+        totalSkillCount: skillResourceClosureResults.reduce((sum, item) => sum + item.skillCount, 0),
+        totalReferenceCount: skillResourceClosureResults.reduce((sum, item) => sum + item.referenceCount, 0),
+        totalSourceOnlyCount: skillResourceClosureResults.reduce((sum, item) => sum + item.sourceOnlyCount, 0),
+        totalFindingCount: 0,
+      },
       verificationGates: config.verificationGates ?? [],
       snapshotDigest: overallSnapshotDigest,
       ...(production ? {

package/src/commands/publish.mjs

@@ -41,6 +41,12 @@ import {
   reObservePreviousPublicBaseline,
 } from '../core/previous-public-baseline.mjs';
 import { createEvidenceWriter } from '../core/evidence.mjs';
+import {
+  CHECKER_VERSION as SKILL_RESOURCE_CHECKER_VERSION,
+  assertSkillResourceClosureReceipt,
+  checkSkillResourceClosure,
+  createSkillResourceClosureReceipt,
+} from '../core/skill-resource-closure.mjs';
 import {
   ADAPTER_ACTION_TYPE_MAP,
   TIER_TABLE,
@@ -521,6 +527,7 @@ export async function publishRelease(options) {
     if (productionMode && !isProductionPlan) {
       throw new ReleaseError(GATE_FAILED, 'production publish requires a github-npm-v1 frozen plan');
     }
+    const verifiedFrozenSnapshots = new Map();
     if (isProductionPlan) {
       if (!plan.production.assetRoot || plan.production.assetRoot === '.') {
         throw new ReleaseError(GATE_FAILED, 'production plan requires a dedicated assetRoot');
@@ -566,6 +573,7 @@ export async function publishRelease(options) {
           snapshotPath: frozen.path,
           expectedDigest: frozen.manifestDigest,
         });
+        verifiedFrozenSnapshots.set(unit.id, snapshot.snapshotDir);
         assertInsideAssetRoot(assetRoot, snapshot.snapshotDir, 'frozen snapshot');
         const git = await verifyFrozenGitRepository({
           root,
@@ -599,6 +607,60 @@ export async function publishRelease(options) {
       await evidence.append({ phase: 'safety-gate', gate: 'frozen-artifacts', status: 'passed' });
     }
 
+    // =======================================================================
+    // Safety Gate 2c: Skill resource closure recheck
+    // Re-run the skill resource closure check on each unit's frozen snapshot.
+    // Requires findingCount=0 and receipt matches the plan.
+    // =======================================================================
+    if (plan.skillResourceClosure) {
+      await evidence.append({ phase: 'safety-gate', gate: 'skill-resource-closure', status: 'started' });
+      const expectedReceipts = plan.skillResourceClosure.unitReceipts ?? [];
+      if (plan.skillResourceClosure.checkerVersion !== SKILL_RESOURCE_CHECKER_VERSION) {
+        throw new ReleaseError(
+          GATE_FAILED,
+          `skill resource closure checker version mismatch: plan=${plan.skillResourceClosure.checkerVersion}, current=${SKILL_RESOURCE_CHECKER_VERSION}`,
+        );
+      }
+      if (expectedReceipts.length !== plan.units.length) {
+        throw new ReleaseError(GATE_FAILED, 'skill resource closure receipt set does not cover every release unit');
+      }
+
+      for (const [unitId, snapshotDir] of verifiedFrozenSnapshots) {
+        const expected = expectedReceipts.find((item) => item.unitId === unitId);
+        if (!expected) {
+          throw new ReleaseError(GATE_FAILED, `skill resource closure receipt missing for unit "${unitId}"`);
+        }
+        const closureResult = await checkSkillResourceClosure({
+          snapshotDir,
+          host: 'root',
+        });
+        if (closureResult.findings.length > 0) {
+          await evidence.append({
+            phase: 'safety-gate',
+            gate: 'skill-resource-closure',
+            status: 'failed',
+            unitId,
+            findingCount: closureResult.findings.length,
+          });
+          throw new ReleaseError(
+            GATE_FAILED,
+            `skill resource closure recheck failed for unit "${unitId}": ${closureResult.findings.length} finding(s)`,
+            { unitId, findings: closureResult.findings },
+          );
+        }
+        const observed = createSkillResourceClosureReceipt(closureResult, { unitId });
+        assertSkillResourceClosureReceipt(expected, observed, `unit "${unitId}"`);
+      }
+
+      await evidence.append({
+        phase: 'safety-gate',
+        gate: 'skill-resource-closure',
+        status: 'passed',
+        receiptCount: expectedReceipts.length,
+        recheckedReceiptCount: verifiedFrozenSnapshots.size,
+      });
+    }
+
     // =======================================================================
     // Safety Gates 3-7: Load and validate approval record (shared)
     // =======================================================================