release-skill 0.2.2 → 0.2.4

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,29 @@ import {
   resolveNpmRegistryAuthToken,
 } from '../adapters/npm.mjs';
 import { runConsumerVerificationGates } from '../core/verification-gates.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 +99,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
 // ---------------------------------------------------------------------------
@@ -519,6 +548,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 +566,7 @@ export async function verifyRelease(options) {
     npmExecutor,
     verificationGatesAuthorized,
     gateEnv,
+    previousVerifyRun,
   } = options ?? {};
 
   const clockFn = typeof clockOpt === 'function' ? clockOpt : defaultClock;
@@ -697,9 +728,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 +766,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 +917,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 +935,105 @@ 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,
+          });
+
+          if (skipDecision === 'NOT_REQUIRED_UNCHANGED') {
+            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 +1056,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 +1100,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,
+            },
           );
         }
 
@@ -849,7 +1114,9 @@ export async function verifyRelease(options) {
           ? 'claude-plugin'
           : action.type === 'codex-marketplace-install'
             ? 'codex-plugin'
-            : 'kimi-plugin';
+            : action.type === 'codebuddy-marketplace-install'
+              ? 'codebuddy-plugin'
+              : 'kimi-plugin';
         const installPath = verifyResult.observation?.installPath;
         consumerGateResults.push(...await runConsumerVerificationGates({
           plan,
@@ -868,10 +1135,14 @@ export async function verifyRelease(options) {
                   HOME: resolve(runDir, 'consumers', `codex-${action.parameters.plugin}`),
                   CODEX_HOME: resolve(runDir, 'consumers', `codex-${action.parameters.plugin}`),
                 }
-              : {
-                  HOME: resolve(runDir, 'consumers', `kimi-${action.parameters.plugin}`),
-                  KIMI_CODE_HOME: resolve(runDir, 'consumers', `kimi-${action.parameters.plugin}`),
-                },
+              : action.type === 'codebuddy-marketplace-install'
+                ? {
+                    HOME: resolve(runDir, 'consumers', `codebuddy-${action.parameters.plugin}`),
+                  }
+                : {
+                    HOME: resolve(runDir, 'consumers', `kimi-${action.parameters.plugin}`),
+                    KIMI_CODE_HOME: resolve(runDir, 'consumers', `kimi-${action.parameters.plugin}`),
+                  },
         }));
       } else {
         // --- Non-marketplace: read-only adapter.verify() ---
@@ -895,7 +1166,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,
         };
@@ -913,7 +1184,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,
+            },
           );
         }
       }
@@ -988,13 +1265,26 @@ 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,
       startedAt: clockFn(),
       finishedAt: clockFn(),
     };

package/src/core/baseline.mjs

@@ -38,11 +38,24 @@ const CONTROL_PLANE_PREFIXES = [
   '.release-skill/runs',
   '.release-skill/transactions',
   '.release-skill/kimi-attestations',
+  // codebuddy-attestations: same rationale as kimi-attestations above.
+  // Holds CodeBuddy's closure-protocol lifecycle artifacts: manual install
+  // requirements and human attestations bound to planDigest, payloadDigest,
+  // version, install path, responsible person, and expiry. Neither is
+  // publishable source or project configuration — they never enter the frozen
+  // snapshot — so excluding them keeps reconcile's own requirement output and
+  // the flow-required attestation from invalidating the baseline.
+  '.release-skill/codebuddy-attestations',
   // T3.2 incremental hook cache: a pure local optimisation written by prepare.
   // Excluding it keeps cache records from destabilising workspaceDigest on
   // every prepare (and hook-cache.mjs also skips this prefix when fingerprinting
   // inputs, so records never hash themselves).
   '.release-skill/cache',
+  // waivers: exception records with reason, responsible person, and expiry.
+  // Like attestations, they are runtime closure artifacts — not publishable
+  // source or project configuration — so excluding them keeps waiver writes
+  // from invalidating the workspace baseline.
+  '.release-skill/waivers',
 ];
 const RESERVED_CONTROL_PREFIXES = [
   ...CONTROL_PLANE_PREFIXES,
@@ -159,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}`);
   }

package/src/core/checkpoints.mjs

@@ -66,13 +66,14 @@ export const ADAPTER_ACTION_TYPE_MAP = {
  *   `push-snapshot` (the frozen commit must exist on the remote before a tag
  *   or branch tip can point at it). `npm-publish` has no git dependency and is
  *   placed in Tier 1 only for conservative scheduling.
- * - Tier 2 `github-release` and the claude/codex marketplace installs depend
- *   on Tier 1 `create-tag` (release `--verify-tag`; install ref is the tag).
- * - Tier 3 `kimi-marketplace-install` depends on Tier 2 `github-release`
- *   (its install URL points at the Release page). `codebuddy-marketplace-install`
- *   is also a non-automatable human-attestation closure and runs in Tier 3 after
- *   the automated writes (its install is from a unified marketplace, proven by a
- *   human attestation rather than an automated install checkpoint).
+ * - Tier 2 `github-release` depends on Tier 1 `create-tag` (release `--verify-tag`).
+ *
+ * Marketplace actions (claude/codex/kimi/codebuddy-marketplace-install) are
+ * included in the tier table for ADAPTER_ACTION_TYPE_MAP lookup but are
+ * filtered out before tier grouping in both publish and reconcile. They are
+ * recorded as DEFERRED with CONSUMER_VERIFICATION_DEFERRED reason and never
+ * participate in tier execution. Their verification is handled exclusively
+ * by the verify command.
  *
  * Action types not listed in any tier are unknown to the scheduler and fail
  * closed (see groupActionsByTier); they are never silently scheduled.
@@ -146,3 +147,45 @@ export function groupActionsByTier(orderedActions) {
   }
   return { tiers, unknown };
 }
+
+/**
+ * 远端写入动作类型集合。
+ * 这些动作的结果决定 PUBLISHED 状态：全部一致后即可进入 PUBLISHED。
+ */
+export const REMOTE_WRITE_ACTION_TYPES = new Set([
+  'push-commit',
+  'push-snapshot',
+  'set-default-branch',
+  'create-tag',
+  'npm-publish',
+  'github-release',
+]);
+
+/**
+ * 市场安装动作类型集合。
+ * 这些动作的结果记录在 run 中，但不阻止 PUBLISHED 状态。
+ */
+export const MARKETPLACE_ACTION_TYPES = new Set([
+  'claude-marketplace-install',
+  'codex-marketplace-install',
+  'kimi-marketplace-install',
+  'codebuddy-marketplace-install',
+]);
+
+/**
+ * 判断动作类型是否为远端写入动作。
+ * @param {string} actionType - 计划中的动作类型
+ * @returns {boolean}
+ */
+export function isRemoteWriteAction(actionType) {
+  return REMOTE_WRITE_ACTION_TYPES.has(actionType);
+}
+
+/**
+ * 判断动作类型是否为市场安装动作。
+ * @param {string} actionType - 计划中的动作类型
+ * @returns {boolean}
+ */
+export function isMarketplaceAction(actionType) {
+  return MARKETPLACE_ACTION_TYPES.has(actionType);
+}

package/src/core/config.mjs

@@ -346,6 +346,21 @@ export async function loadProjectConfig({ root, configPath } = {}) {
   }
   } // end of contextual prevalidation else block
 
+  // --- Normalize marketplaceSourceType for old configs ---
+  // Old configs may lack marketplaceSourceType; determine by marketplaceRepo existence.
+  // This runs before schema validation so the required rule passes.
+  if (Array.isArray(config.releaseUnits)) {
+    for (const unit of config.releaseUnits) {
+      if (!unit?.distributions) continue;
+      for (const dist of unit.distributions) {
+        if (dist.type === 'npm') continue;
+        if (dist.marketplaceSourceType === undefined || dist.marketplaceSourceType === null) {
+          dist.marketplaceSourceType = dist.marketplaceRepo ? 'standalone-index' : 'bundled-family';
+        }
+      }
+    }
+  }
+
   // --- Schema validation (using formal JSON schema) ---
   const valid = validateConfig(config);
   if (!valid) {

package/src/core/errors.mjs

@@ -87,6 +87,7 @@ const EXIT_CODE_MAP = Object.freeze({
   RELEASE_DOCS_CONFLICT: 44,
   RELEASE_DOCS_REFRESH_STALE: 45,
   RELEASE_DOCS_STALE: 46,
+  CONSUMER_VERIFICATION_DEFERRED: 47,
 });
 
 // ---- Error code constants ----
@@ -128,6 +129,7 @@ export const RELEASE_DOCS_TRANSLATION_MISSING = 'RELEASE_DOCS_TRANSLATION_MISSIN
 export const RELEASE_DOCS_CONFLICT = 'RELEASE_DOCS_CONFLICT';
 export const RELEASE_DOCS_REFRESH_STALE = 'RELEASE_DOCS_REFRESH_STALE';
 export const RELEASE_DOCS_STALE = 'RELEASE_DOCS_STALE';
+export const CONSUMER_VERIFICATION_DEFERRED = 'CONSUMER_VERIFICATION_DEFERRED';
 
 /**
  * Typed error for release-skill operations.