release-skill 0.2.1 → 0.2.3

package/src/core/plan.mjs

@@ -776,6 +776,19 @@ export function validatePlanActionCompleteness(plan, options = {}) {
           );
         }
 
+        // External independent marketplace form: the distribution declares
+        // marketplaceRepo, so the install targets the external marketplace
+        // repository instead of publicRepo. Only platforms with a marketplace
+        // add capability (marketplaceRefForm !== null: claude=name, codex=sha)
+        // may carry it; kimi/codebuddy fail closed. Inline form (no
+        // marketplaceRepo) keeps every assertion below byte-for-byte.
+        const externalMarketplace = dist.marketplaceRepo !== undefined && dist.marketplaceRepo !== null;
+        if (externalMarketplace && platform.marketplaceRefForm === null) {
+          failures.push(
+            `unit "${unitId}", action "${action.id}": ${platform.distributionType} distribution declares marketplaceRepo but the platform has no marketplace add capability`,
+          );
+        }
+
         // Parameter checks
         _checkRequired(action, 'parameters.consumer', action.parameters?.consumer, platform.id, unitId, failures);
         _checkRequired(action, 'parameters.plugin', action.parameters?.plugin, plugin, unitId, failures);
@@ -792,12 +805,53 @@ export function validatePlanActionCompleteness(plan, options = {}) {
             `unit "${unitId}", action "${action.id}": parameters.marketplace is "${action.parameters.marketplace}", expected optional legacy value "${marketplace}"`,
           );
         }
-        _checkRequired(action, 'parameters.repo', action.parameters?.repo, publicRepo, unitId, failures);
+        if (externalMarketplace) {
+          // External form: the install repo is the external marketplace repo,
+          // not publicRepo; marketplaceLocation is the action-level marker.
+          _checkRequired(action, 'parameters.repo', action.parameters?.repo, dist.marketplaceRepo, unitId, failures);
+          _checkRequired(action, 'parameters.marketplaceLocation', action.parameters?.marketplaceLocation, 'external', unitId, failures);
+        } else {
+          _checkRequired(action, 'parameters.repo', action.parameters?.repo, publicRepo, unitId, failures);
+        }
         _checkRequired(action, 'parameters.version', action.parameters?.version, targetVersion, unitId, failures);
         _checkRequired(action, 'parameters.entrySkill', action.parameters?.entrySkill, entrySkill, unitId, failures);
         if (production) {
+          // snapshotPath/manifestDigest always bind the unit's own frozen
+          // snapshot — the payload authority is unchanged for external form.
           _checkRequired(action, 'parameters.snapshotPath', action.parameters?.snapshotPath, frozen?.path, unitId, failures);
-          _checkRequired(action, 'parameters.ref', action.parameters?.ref, expectedTag, unitId, failures);
+          if (externalMarketplace) {
+            // The add-ref is frozen online by prepare (codex=commit sha,
+            // claude=default branch name) and cannot be re-derived offline;
+            // validate structural safety plus self-consistency with expected.ref.
+            const ref = action.parameters?.ref;
+            if (ref === undefined || ref === null) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.ref is missing, expected the frozen external marketplace add-ref`,
+              );
+            } else if (!_isStructurallySafeExternalRef(ref)) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.ref is not a structurally safe ref: ${JSON.stringify(ref)}`,
+              );
+            } else if (ref !== action.expected?.ref) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.ref is "${ref}", expected self-consistent expected.ref "${action.expected?.ref}"`,
+              );
+            }
+            // marketplaceCommitSha is the frozen 40-hex marketplace HEAD
+            // (online freeze, offline completeness — same model as manifestDigest).
+            const sha = action.parameters?.marketplaceCommitSha;
+            if (sha === undefined || sha === null) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.marketplaceCommitSha is missing, expected a frozen 40-hex commit sha`,
+              );
+            } else if (typeof sha !== 'string' || !EXTERNAL_MARKETPLACE_SHA_RE.test(sha)) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.marketplaceCommitSha must be a 40-hex commit sha, got: ${JSON.stringify(sha)}`,
+              );
+            }
+          } else {
+            _checkRequired(action, 'parameters.ref', action.parameters?.ref, expectedTag, unitId, failures);
+          }
           _checkRequired(action, 'parameters.manifestDigest', action.parameters?.manifestDigest, frozen?.manifestDigest, unitId, failures);
         }
         // timeoutMs is mandatory for all marketplace install actions.
@@ -828,6 +882,184 @@ export function validatePlanActionCompleteness(plan, options = {}) {
           }
         }
 
+        // sourceCommit: frozen plugin source commit, binding the marketplace
+        // install action to the unit's frozen snapshot commit. Both forms
+        // require it in production plans; non-production diagnostic plans may
+        // omit it (never冒充生产计划).
+        if (production) {
+          _checkRequired(action, 'parameters.sourceCommit', action.parameters?.sourceCommit, frozen?.commit, unitId, failures);
+        }
+
+        // --- sourceDescriptor validation (marketplace source identity contract) ---
+        // Validates that marketplaceForm and sourceDescriptor.form are consistent,
+        // all form-specific fields are present and non-null, pluginRepo !== marketplaceRepo
+        // for standalone-index, and no mixed/extra fields exist.
+        // Only applies to platforms that require marketplace (claude, codex).
+        // Non-automatable platforms (kimi, codebuddy) use human-attestation
+        // and carry no marketplace form or source descriptor.
+        // Legacy plans (pre-sourceDescriptor) with legacyCompatibility are tolerated.
+        if (requiresMarketplace) {
+          const sd = action.parameters?.sourceDescriptor;
+          const mf = action.parameters?.marketplaceForm;
+          if (sd === undefined || sd === null) {
+            if (!options.legacyCompatibility) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.sourceDescriptor is missing; every marketplace install action must carry a complete source descriptor`,
+              );
+            }
+          } else if (typeof sd === 'object') {
+            // 1. marketplaceForm must be present when sourceDescriptor is present
+            if (mf === undefined || mf === null) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": parameters.marketplaceForm is missing but sourceDescriptor is present; form must be explicitly declared`,
+              );
+            }
+            // 2. sourceDescriptor.form must match marketplaceForm
+            if (sd.form !== mf) {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": sourceDescriptor.form "${sd.form}" does not match parameters.marketplaceForm "${mf}"`,
+              );
+            }
+            // 3. Form-specific field completeness and non-null checks
+            // payloadDigest is allowed to be null in non-production plans
+            // (the frozen manifestDigest is only available after production freeze)
+            const BUNDLED_REQUIRED = ['form', 'repo', 'marketplaceEntry', 'pluginSubpath'];
+            const STANDALONE_REQUIRED = ['form', 'marketplaceRepo', 'marketplaceEntry', 'pluginRepo', 'sourceType'];
+            // Production-only fields that may be null in non-production plans
+            const PROD_ONLY_FIELDS = ['marketplaceCommitSha', 'ref', 'payloadDigest'];
+
+            if (sd.form === 'bundled-family') {
+              // Check bundled-family required fields are present and non-null
+              for (const field of BUNDLED_REQUIRED) {
+                if (sd[field] === undefined || sd[field] === null) {
+                  failures.push(
+                    `unit "${unitId}", action "${action.id}": sourceDescriptor.${field} is missing or null; bundled-family form requires all identity fields to be non-null`,
+                  );
+                }
+              }
+              // commit must be non-null in production plans (frozen from asset)
+              if (production && (sd.commit === undefined || sd.commit === null)) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.commit is missing or null; production bundled-family plans require a frozen commit`,
+                );
+              }
+              // commit must match frozenSnapshot.commit (production binding)
+              if (production && sd.commit !== undefined && sd.commit !== null &&
+                  frozen?.commit !== undefined && sd.commit !== frozen.commit) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.commit does not match frozenSnapshot.commit`,
+                );
+              }
+              // payloadDigest must be non-null in production plans
+              if (production && (sd.payloadDigest === undefined || sd.payloadDigest === null)) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.payloadDigest is missing or null; production plans require a frozen payload digest`,
+                );
+              }
+              // Prohibit standalone-index fields in bundled-family
+              const STANDALONE_ONLY = ['marketplaceRepo', 'pluginRepo', 'sourceType', 'marketplaceCommitSha', 'ref'];
+              for (const field of STANDALONE_ONLY) {
+                if (sd[field] !== undefined) {
+                  failures.push(
+                    `unit "${unitId}", action "${action.id}": sourceDescriptor.${field} is unexpected for bundled-family form; mixed fields are prohibited`,
+                  );
+                }
+              }
+              // repo must match the action's repo (publicRepo for bundled-family)
+              if (sd.repo !== undefined && sd.repo !== null && sd.repo !== publicRepo) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.repo "${sd.repo}" does not match unit publicRepo "${publicRepo}"`,
+                );
+              }
+              // marketplaceEntry must match action.plugin
+              if (sd.marketplaceEntry !== undefined && sd.marketplaceEntry !== null && sd.marketplaceEntry !== plugin) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.marketplaceEntry "${sd.marketplaceEntry}" does not match action plugin "${plugin}"`,
+                );
+              }
+              // payloadDigest must match manifestDigest (when both are present)
+              if (production && sd.payloadDigest !== undefined && sd.payloadDigest !== null &&
+                  frozen?.manifestDigest !== undefined && sd.payloadDigest !== frozen.manifestDigest) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.payloadDigest does not match frozen manifestDigest`,
+                );
+              }
+            } else if (sd.form === 'standalone-index') {
+              // Check standalone-index required fields are present and non-null
+              for (const field of STANDALONE_REQUIRED) {
+                if (sd[field] === undefined || sd[field] === null) {
+                  failures.push(
+                    `unit "${unitId}", action "${action.id}": sourceDescriptor.${field} is missing or null; standalone-index form requires all identity fields to be non-null`,
+                  );
+                }
+              }
+              // Production-only fields: must be non-null in production plans
+              if (production) {
+                for (const field of PROD_ONLY_FIELDS) {
+                  if (sd[field] === undefined || sd[field] === null) {
+                    failures.push(
+                      `unit "${unitId}", action "${action.id}": sourceDescriptor.${field} is missing or null; production standalone-index requires all fields to be non-null`,
+                    );
+                  }
+                }
+              }
+              // Prohibit bundled-family fields in standalone-index
+              const BUNDLED_ONLY = ['repo', 'commit', 'pluginSubpath'];
+              for (const field of BUNDLED_ONLY) {
+                if (sd[field] !== undefined) {
+                  failures.push(
+                    `unit "${unitId}", action "${action.id}": sourceDescriptor.${field} is unexpected for standalone-index form; mixed fields are prohibited`,
+                  );
+                }
+              }
+              // pluginRepo must NOT equal marketplaceRepo
+              if (sd.pluginRepo !== undefined && sd.pluginRepo !== null &&
+                  sd.marketplaceRepo !== undefined && sd.marketplaceRepo !== null &&
+                  sd.pluginRepo === sd.marketplaceRepo) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.pluginRepo must not equal marketplaceRepo; the plugin repo and marketplace repo are distinct repositories`,
+                );
+              }
+              // marketplaceRepo must match action.repo (for standalone-index, repo is the external marketplace)
+              if (externalMarketplace && sd.marketplaceRepo !== undefined && sd.marketplaceRepo !== null &&
+                  sd.marketplaceRepo !== dist.marketplaceRepo) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.marketplaceRepo "${sd.marketplaceRepo}" does not match distribution marketplaceRepo "${dist.marketplaceRepo}"`,
+                );
+              }
+              // pluginRepo must match the unit's publicRepo
+              if (sd.pluginRepo !== undefined && sd.pluginRepo !== null && sd.pluginRepo !== publicRepo) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.pluginRepo "${sd.pluginRepo}" does not match unit publicRepo "${publicRepo}"`,
+                );
+              }
+              // marketplaceEntry must match action.plugin
+              if (sd.marketplaceEntry !== undefined && sd.marketplaceEntry !== null && sd.marketplaceEntry !== plugin) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.marketplaceEntry "${sd.marketplaceEntry}" does not match action plugin "${plugin}"`,
+                );
+              }
+              // sourceType must be 'marketplace-entry'
+              if (sd.sourceType !== undefined && sd.sourceType !== null && sd.sourceType !== 'marketplace-entry') {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.sourceType "${sd.sourceType}" is unexpected; standalone-index sourceType must be "marketplace-entry"`,
+                );
+              }
+              // payloadDigest must match manifestDigest (when both are present)
+              if (production && sd.payloadDigest !== undefined && sd.payloadDigest !== null &&
+                  frozen?.manifestDigest !== undefined && sd.payloadDigest !== frozen.manifestDigest) {
+                failures.push(
+                  `unit "${unitId}", action "${action.id}": sourceDescriptor.payloadDigest does not match frozen manifestDigest`,
+                );
+              }
+            } else {
+              failures.push(
+                `unit "${unitId}", action "${action.id}": sourceDescriptor.form "${sd.form}" is unknown; expected "bundled-family" or "standalone-index"`,
+              );
+            }
+          }
+        }
+
         // Expected checks. Marketplace identity is bound only on platforms
         // whose schema requires it (MINOR-1): a non-marketplace platform's
         // observation never binds a marketplace.
@@ -840,8 +1072,15 @@ export function validatePlanActionCompleteness(plan, options = {}) {
         _checkRequired(action, 'expected.entrySkill', action.expected?.entrySkill, entrySkill, unitId, failures);
         if (production) {
           _checkRequired(action, 'expected.consumer', action.expected?.consumer, platform.id, unitId, failures);
-          _checkRequired(action, 'expected.repo', action.expected?.repo, publicRepo, unitId, failures);
-          _checkRequired(action, 'expected.ref', action.expected?.ref, expectedTag, unitId, failures);
+          if (externalMarketplace) {
+            _checkRequired(action, 'expected.repo', action.expected?.repo, dist.marketplaceRepo, unitId, failures);
+            _checkRequired(action, 'expected.ref', action.expected?.ref, action.parameters?.ref, unitId, failures);
+            _checkRequired(action, 'expected.marketplaceLocation', action.expected?.marketplaceLocation, 'external', unitId, failures);
+            _checkRequired(action, 'expected.marketplaceCommitSha', action.expected?.marketplaceCommitSha, action.parameters?.marketplaceCommitSha, unitId, failures);
+          } else {
+            _checkRequired(action, 'expected.repo', action.expected?.repo, publicRepo, unitId, failures);
+            _checkRequired(action, 'expected.ref', action.expected?.ref, expectedTag, unitId, failures);
+          }
           _checkRequired(action, 'expected.entrySkillFound', action.expected?.entrySkillFound, true, unitId, failures);
           _checkRequired(action, 'expected.manifestDigest', action.expected?.manifestDigest, frozen?.manifestDigest, unitId, failures);
         }
@@ -946,3 +1185,35 @@ function _checkRequired(action, fieldPath, actual, expected, unitId, failures) {
     );
   }
 }
+
+// External independent marketplace form (external-marketplace): a frozen
+// marketplace HEAD commit sha is a 40-char lowercase hex string.
+const EXTERNAL_MARKETPLACE_SHA_RE = /^[0-9a-f]{40}$/;
+
+/**
+ * Structural safety check for an externally frozen marketplace add-ref.
+ *
+ * The add-ref (codex=commit sha, claude=default branch name) is frozen online
+ * by prepare and cannot be re-derived offline; full injection-safety validation
+ * already happened at freeze time (plugin-marketplace `validateSafeRef`). The
+ * offline completeness gate re-checks structural well-formedness so a tampered
+ * or corrupted frozen ref fails closed here too. Mirrors that validator's rules.
+ *
+ * @param {unknown} ref
+ * @returns {boolean}
+ */
+function _isStructurallySafeExternalRef(ref) {
+  if (typeof ref !== 'string' || ref.length === 0) return false;
+  if (/[\x00-\x1f]/.test(ref)) return false;
+  if (ref.startsWith('-')) return false;
+  if (ref.includes('\\')) return false;
+  if (ref.includes('//')) return false;
+  if (ref.startsWith('/') || ref.endsWith('/')) return false;
+  if (ref.endsWith('.')) return false;
+  if (ref.endsWith('.lock')) return false;
+  if (ref.includes('@{')) return false;
+  if (ref === '@') return false;
+  if (ref.includes('..')) return false;
+  if (/[;|&`$(){}]/.test(ref)) return false;
+  return /^[a-zA-Z0-9][a-zA-Z0-9._/-]*$/.test(ref);
+}

package/src/core/verification-gates.mjs

@@ -57,7 +57,7 @@ function validateGate(gate) {
   if (!gate.scope || typeof gate.scope.unit !== 'string') {
     throw gateError(gate, 'must declare scope.unit');
   }
-  if (gate.phase === 'consumer-verify' && !['npm', 'claude-plugin', 'codex-plugin', 'kimi-plugin'].includes(gate.scope.distribution)) {
+  if (gate.phase === 'consumer-verify' && !['npm', 'claude-plugin', 'codex-plugin', 'kimi-plugin', 'codebuddy-plugin'].includes(gate.scope.distribution)) {
     throw gateError(gate, 'consumer-verify must declare a supported scope.distribution');
   }
   if (!Array.isArray(gate.command) || gate.command.length === 0 || gate.command.some((value) => typeof value !== 'string')) {