release-skill 0.7.6 → 0.7.7

package/package.json

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

package/platform-manifest.json

@@ -2,11 +2,11 @@
   "schemaVersion": "1.0.0",
   "platformId": "release-skill",
   "platformName": "release-skill Plugin Platform",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "logicalRoot": "skills-src/",
-  "logicalRootDigest": "7889a5f745d1f51ede024d4df68853128f2440a05f430da77a25b78c7c3d396f",
-  "projectionDigest": "9709f8e22722faaca894d067dce7a9534813a6abf241f00e796a5a47b5f69f72",
-  "projectionId": "release-skill:platform:0.7.6",
+  "logicalRootDigest": "b261a4cc49e6dc52dabddb083c22e414902fb269d5879ad01ef8146ceffd7bc7",
+  "projectionDigest": "6629de035a25005fd4676b09a0526a46f992a33d974cadd542b0c964d7f906ff",
+  "projectionId": "release-skill:platform:0.7.7",
   "manifestRequired": true,
   "projectionSources": {
     "skills-src-root": {

package/references/02-project-config.md

@@ -27,6 +27,10 @@ project:
   defaultBranch: <string>        # workspace 远端默认分支，必填；不限定为 main
   sourceRepository: <owner/repo> # workspace 源仓库；生产发布必填
 
+publicSourceAuthorityReceipt:    # 可选；把源码坐标与多个 npm tarball 绑定为公开 Release asset
+  coordinatorUnitId: <release-unit-id>
+  subjectUnitIds: [<release-unit-id>]
+
 releaseUnits:               # 发布单元数组，至少 1 个
   - id: <string>            # 唯一标识
     source: <string>        # 源码相对路径（相对项目根目录）
@@ -108,6 +112,20 @@ policy:                     # 可选，安全策略
   forbiddenContentPatterns: [<string>]
 ```
 
+`publicSourceAuthorityReceipt` 只适用于 production prepare。`coordinatorUnitId`
+指定承载该文件的 GitHub Release；`subjectUnitIds` 必须引用现有 release unit，且每个
+unit 恰好声明一个 npm distribution。prepare 等所有 subject tarball 冻结后生成
+`source-authority-receipt.json`，其公开结构固定为：
+
+```json
+{"schemaVersion":1,"kind":"skill-family.source-authority-receipt","sourceRepository":"owner/workspace","sourceBaseCommit":"<full-commit>","subjects":[{"packageName":"@scope/package","version":"1.2.3","filename":"scope-package-1.2.3.tgz","sha256":"<sha256>"}]}
+```
+
+该文件使用 canonical JSON，不带自摘要，也不包含 release-skill 的计划、运行或批准字段。
+冻结计划记录文件 SHA-256；publish 将相同字节上传到 coordinator GitHub Release，verify
+重新下载远端字节并核对 SHA-256。离线消费者只需该文件和其中 subjects 对应的精确 tarball，便可
+核对包名、版本、文件名、tarball SHA-256、源码仓库与源码基线提交。
+
 `postPublish` 只能位于某个 `releaseUnits[]` 条目内。下面的完整结构样例会由 schema 契约测试直接读取并校验，避免文档层级再次漂移：
 
 ```yaml

package/schemas/release-plan.schema.json

@@ -53,6 +53,53 @@
         }
       }
     },
+    "publicSourceAuthorityReceipt": {
+      "type": "object",
+      "required": [
+        "coordinatorUnitId",
+        "subjectUnitIds",
+        "asset"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "coordinatorUnitId": {
+          "type": "string",
+          "pattern": "^(?!\\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._-]*$"
+        },
+        "subjectUnitIds": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "pattern": "^(?!\\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._-]*$"
+          }
+        },
+        "asset": {
+          "type": "object",
+          "required": [
+            "name",
+            "path",
+            "sha256"
+          ],
+          "additionalProperties": false,
+          "properties": {
+            "name": {
+              "const": "source-authority-receipt.json"
+            },
+            "path": {
+              "type": "string",
+              "minLength": 1,
+              "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$))(?!.*\\\\).+$"
+            },
+            "sha256": {
+              "type": "string",
+              "pattern": "^[a-f0-9]{64}$"
+            }
+          }
+        }
+      }
+    },
     "baseline": {
       "type": "object",
       "required": [

package/schemas/release-project.schema.json

@@ -44,6 +44,30 @@
         }
       }
     },
+    "publicSourceAuthorityReceipt": {
+      "type": "object",
+      "description": "Optional public source-authority receipt uploaded to one coordinator GitHub Release after all subject npm tarballs are frozen.",
+      "required": [
+        "coordinatorUnitId",
+        "subjectUnitIds"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "coordinatorUnitId": {
+          "type": "string",
+          "pattern": "^(?!\\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._-]*$"
+        },
+        "subjectUnitIds": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "type": "string",
+            "pattern": "^(?!\\.{1,2}$)[A-Za-z0-9][A-Za-z0-9._-]*$"
+          }
+        }
+      }
+    },
     "releaseUnits": {
       "type": "array",
       "minItems": 1,

package/skills/release-prepare/SKILL.md

@@ -33,6 +33,10 @@ description: Freeze an immutable release plan with local configuration, document
 
 若用户明确要求 GitHub+npm 生产发布，加入 `--production`。该模式还会封存独立
 Git commit/tree 和 npm tarball，并把路径、SHA/integrity、branch/tag 写入计划。
+配置声明 `publicSourceAuthorityReceipt` 时，prepare 必须在所有 subject npm tarball
+冻结后生成 `source-authority-receipt.json`，并把该文件的路径与 SHA-256 绑定到
+coordinator unit 的 `github-release` action。该能力不支持非生产 prepare；不得手工
+补写 receipt 或把私有 plan/run 字段复制进公开文件。
 每个 npm tarball 在计划落盘前必须静态验证 `package.json` 的具体
 `bin`/`main`/`module`/`types`/`typings`/`exports` 入口均为 tarball 内普通文件；
 该门禁不依赖项目是否配置 `requiredPublicFiles` 或 `smokeBin`。通配符 exports 不做

package/skills-src/release-prepare/SKILL.md

@@ -33,6 +33,10 @@ description: Freeze an immutable release plan with local configuration, document
 
 若用户明确要求 GitHub+npm 生产发布，加入 `--production`。该模式还会封存独立
 Git commit/tree 和 npm tarball，并把路径、SHA/integrity、branch/tag 写入计划。
+配置声明 `publicSourceAuthorityReceipt` 时，prepare 必须在所有 subject npm tarball
+冻结后生成 `source-authority-receipt.json`，并把该文件的路径与 SHA-256 绑定到
+coordinator unit 的 `github-release` action。该能力不支持非生产 prepare；不得手工
+补写 receipt 或把私有 plan/run 字段复制进公开文件。
 每个 npm tarball 在计划落盘前必须静态验证 `package.json` 的具体
 `bin`/`main`/`module`/`types`/`typings`/`exports` 入口均为 tarball 内普通文件；
 该门禁不依赖项目是否配置 `requiredPublicFiles` 或 `smokeBin`。通配符 exports 不做

package/src/adapters/git-github.mjs

@@ -8,8 +8,10 @@ import {
   createResult,
   matchObservation,
 } from './contract.mjs';
-import { resolveFrozenPath, verifyFrozenDirectoryStructure } from '../snapshot/frozen.mjs';
+import { resolveFrozenPath, verifyFrozenDirectoryStructure, verifyFrozenFile } from '../snapshot/frozen.mjs';
 import { githubRepositoryUrl } from './push-snapshot.mjs';
+import { digestReleaseAssetIdentities, normalizeReleaseAssets } from '../core/release-assets.mjs';
+import { sha256Hex } from '../core/digest.mjs';
 
 const execFile = promisify(execFileCb);
 const NAME = 'git-github';
@@ -91,6 +93,82 @@ async function readRemoteBranchCommit(action, exec) {
   return stdout.trim().split(/\s+/)[0] ?? '';
 }
 
+async function validateLocalReleaseAssets(action, context) {
+  const assets = normalizeReleaseAssets(action.releaseAssets);
+  const verified = [];
+  for (const asset of assets) {
+    const file = await verifyFrozenFile({
+      root: context.root,
+      filePath: asset.path,
+      expectedSha256: asset.sha256,
+      label: `frozen GitHub Release asset "${asset.name}"`,
+    });
+    verified.push({ ...asset, physical: file.physical });
+  }
+  return verified;
+}
+
+async function readReleaseWithAssets(action, context, exec) {
+  const environment = { ...process.env, GH_HOST: action.githubHost ?? 'github.com' };
+  const { stdout } = await exec(
+    'gh',
+    ['api', `repos/${action.repo}/releases/tags/${action.tag}`],
+    { cwd: context.root, shell: false, encoding: 'utf8', env: environment },
+  );
+  const release = JSON.parse(stdout);
+  const commitResult = await exec(
+    'gh',
+    ['api', `repos/${action.repo}/git/ref/tags/${action.tag}`, '--jq', '.object.sha'],
+    { cwd: context.root, shell: false, encoding: 'utf8', env: environment },
+  );
+  const plannedAssets = normalizeReleaseAssets(action.releaseAssets);
+  const observedAssets = [];
+  const missingAssets = [];
+  for (const planned of plannedAssets) {
+    const matches = (release.assets ?? []).filter((asset) => asset?.name === planned.name);
+    if (matches.length > 1) throw new Error(`GitHub Release has duplicate asset name "${planned.name}"`);
+    if (matches.length === 0) {
+      missingAssets.push(planned.name);
+      continue;
+    }
+    const remote = matches[0];
+    if (!Number.isInteger(remote.id)) throw new Error(`GitHub Release asset "${planned.name}" has no stable asset id`);
+    const downloaded = await exec(
+      'gh',
+      ['api', `repos/${action.repo}/releases/assets/${remote.id}`, '-H', 'Accept: application/octet-stream'],
+      { cwd: context.root, shell: false, encoding: null, env: environment, maxBuffer: 64 * 1024 * 1024 },
+    );
+    const bytes = Buffer.isBuffer(downloaded.stdout)
+      ? downloaded.stdout
+      : Buffer.from(downloaded.stdout ?? '', 'utf8');
+    observedAssets.push({ ...planned, sha256: sha256Hex(bytes) });
+  }
+  return {
+    observation: {
+      tag: release.tag_name,
+      commit: commitResult.stdout.trim(),
+      releaseUrl: release.html_url,
+      ...(missingAssets.length > 0
+        ? { exists: false, missingReleaseAssets: missingAssets }
+        : { releaseAssetsDigest: digestReleaseAssetIdentities(observedAssets) }),
+    },
+    missingAssets,
+    observedAssets,
+  };
+}
+
+function assertExistingReleaseCompatible(action, state) {
+  if (state.observation.tag !== action.tag || state.observation.commit !== action.commit) {
+    throw new Error('existing GitHub Release tag or commit conflicts with the frozen plan');
+  }
+  const expectedByName = new Map(normalizeReleaseAssets(action.releaseAssets).map((asset) => [asset.name, asset]));
+  for (const observed of state.observedAssets) {
+    if (expectedByName.get(observed.name)?.sha256 !== observed.sha256) {
+      throw new Error(`GitHub Release asset "${observed.name}" bytes conflict with the frozen plan`);
+    }
+  }
+}
+
 export function createGitGithubAdapter(deps = {}) {
   const exec = deps.exec ?? run;
   return Object.freeze({
@@ -110,6 +188,7 @@ export function createGitGithubAdapter(deps = {}) {
         } else if (action.actionType === ActionType.GITHUB_RELEASE) {
           if (!action.repo || !action.tag) throw new Error('github-release requires repo, tag, and commit');
           validateOid(action.commit);
+          const localAssets = await validateLocalReleaseAssets(action, context);
           await exec('gh', ['auth', 'status'], {
             cwd: context.root,
             shell: false,
@@ -123,12 +202,19 @@ export function createGitGithubAdapter(deps = {}) {
             throw new Error(`cannot access GitHub repository ${action.repo}: ${err.message}`);
           });
           try {
-            await exec('gh', ['api', `repos/${action.repo}/releases/tags/${action.tag}`], {
-              cwd: context.root,
-              shell: false,
-              env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' },
-            });
-            throw new Error(`GitHub Release already exists for ${action.tag}; human intervention required`);
+            if (localAssets.length === 0) {
+              await exec('gh', ['api', `repos/${action.repo}/releases/tags/${action.tag}`], {
+                cwd: context.root,
+                shell: false,
+                env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' },
+              });
+              throw new Error(`GitHub Release already exists for ${action.tag}; human intervention required`);
+            }
+            const state = await readReleaseWithAssets(action, context, exec);
+            assertExistingReleaseCompatible(action, state);
+            if (state.missingAssets.length === 0) {
+              throw new Error(`GitHub Release and assets already exist for ${action.tag}`);
+            }
           } catch (err) {
             if (err.message?.includes('already exists')) throw err;
             if (!isNotFound(err)) throw new Error(`cannot determine GitHub Release uniqueness: ${err.message}`);
@@ -192,13 +278,36 @@ export function createGitGithubAdapter(deps = {}) {
             `refs/tags/${action.tag}`,
           ], { shell: false });
         } else if (action.actionType === ActionType.GITHUB_RELEASE) {
-          await exec('gh', [
-            'release', 'create', action.tag,
-            '--repo', ghRepo(action),
-            '--verify-tag',
-            '--title', action.name ?? `Release ${action.tag}`,
-            '--notes', action.notes ?? `Release ${action.tag}`,
-          ], { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } });
+          const assets = await validateLocalReleaseAssets(action, context);
+          let existing = null;
+          if (assets.length > 0) {
+            try {
+              existing = await readReleaseWithAssets(action, context, exec);
+            } catch (error) {
+              if (!isNotFound(error)) throw error;
+            }
+          }
+          if (existing) {
+            assertExistingReleaseCompatible(action, existing);
+            const missing = new Set(existing.missingAssets);
+            const uploadPaths = assets.filter((asset) => missing.has(asset.name)).map((asset) => asset.physical);
+            if (uploadPaths.length > 0) {
+              await exec('gh', ['release', 'upload', action.tag, '--repo', ghRepo(action), ...uploadPaths], {
+                cwd: context.root,
+                shell: false,
+                env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' },
+              });
+            }
+          } else {
+            await exec('gh', [
+              'release', 'create', action.tag,
+              '--repo', ghRepo(action),
+              '--verify-tag',
+              '--title', action.name ?? `Release ${action.tag}`,
+              '--notes', action.notes ?? `Release ${action.tag}`,
+              ...assets.map((asset) => asset.physical),
+            ], { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } });
+          }
         } else if (action.actionType === ActionType.SET_DEFAULT_BRANCH) {
           validateDefaultBranchAction(action);
           const { stdout: current } = await exec('gh', ['api', `repos/${action.repo}`, '--jq', '.default_branch'], {
@@ -242,18 +351,22 @@ export function createGitGithubAdapter(deps = {}) {
           const { remoteUrl } = await validateTagAction(action, context, exec);
           observation = { tag: action.tag, commit: await readRemoteTag(action, remoteUrl, exec) };
         } else if (action.actionType === ActionType.GITHUB_RELEASE) {
-          const { stdout } = await exec('gh', [
-            'release', 'view', action.tag,
-            '--repo', ghRepo(action),
-            '--json', 'tagName,url',
-          ], { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } });
-          const release = JSON.parse(stdout);
-          const commitResult = await exec(
-            'gh',
-            ['api', `repos/${action.repo}/git/ref/tags/${action.tag}`, '--jq', '.object.sha'],
-            { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } },
-          );
-          observation = { tag: release.tagName, commit: commitResult.stdout.trim(), releaseUrl: release.url };
+          if (normalizeReleaseAssets(action.releaseAssets).length > 0) {
+            observation = (await readReleaseWithAssets(action, context, exec)).observation;
+          } else {
+            const { stdout } = await exec('gh', [
+              'release', 'view', action.tag,
+              '--repo', ghRepo(action),
+              '--json', 'tagName,url',
+            ], { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } });
+            const release = JSON.parse(stdout);
+            const commitResult = await exec(
+              'gh',
+              ['api', `repos/${action.repo}/git/ref/tags/${action.tag}`, '--jq', '.object.sha'],
+              { cwd: context.root, shell: false, env: { ...process.env, GH_HOST: action.githubHost ?? 'github.com' } },
+            );
+            observation = { tag: release.tagName, commit: commitResult.stdout.trim(), releaseUrl: release.url };
+          }
         } else if (action.actionType === ActionType.SET_DEFAULT_BRANCH) {
           validateDefaultBranchAction(action);
           const { stdout: current } = await exec('gh', ['api', `repos/${action.repo}`, '--jq', '.default_branch'], {

package/src/commands/prepare.mjs

@@ -25,7 +25,7 @@ import { promisify } from 'node:util';
 
 const execFile = promisify(execFileCb);
 
-import { classifyPathInput } from 'skill-family-harness-node';
+import { classifyPathInput, writeFileAtomic } from 'skill-family-harness-node';
 import { loadProjectConfig } from '../core/config.mjs';
 import { captureBaseline } from '../core/baseline.mjs';
 import { runHook } from '../core/hooks.mjs';
@@ -62,6 +62,7 @@ import { PKG_ROOT } from '../core/pkg-root.mjs';
 import { writeFrozenMarker, FROZEN_MARKER_FILENAME } from '../core/frozen-marker.mjs';
 import {
   SOURCE_INPUT_ALGORITHM_VERSION,
+  createPublicSourceAuthorityReceipt,
   computeSourceInputClosure,
   checkSourceInputDirty,
   verifySnapshotSourcesMatchClosure,
@@ -80,6 +81,7 @@ import {
   PAYLOAD_SOURCE_TAG_WORKTREE,
 } from '../core/postpublish.mjs';
 import { freezeExecutionBundle, bundleRootForAuthorityDir } from '../core/postpublish-bundle.mjs';
+import { digestReleaseAssetIdentities } from '../core/release-assets.mjs';
 
 // ---------------------------------------------------------------------------
 // 安装契约常量
@@ -1513,7 +1515,7 @@ export async function resolveExternalMarketplaceFreezes({
  * @param {string} realRoot - The project root for relative path calculation.
  * @returns {object[]} Array of external action descriptors.
  */
-export function buildExternalActions(unitResults, resolvedVersions, productionAssets, externalFreezes = new Map(), frozenDistributions = null) {
+export function buildExternalActions(unitResults, resolvedVersions, productionAssets, externalFreezes = new Map(), frozenDistributions = null, publicSourceAuthorityReceipt = null) {
   const actions = [];
 
   if (!productionAssets) {
@@ -1785,6 +1787,9 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
     }
 
     // GitHub release
+    const releaseAssets = publicSourceAuthorityReceipt?.coordinatorUnitId === unit.id
+      ? [publicSourceAuthorityReceipt.asset]
+      : null;
     actions.push({
       id: `github-release-${unit.id}`,
       type: 'github-release',
@@ -1802,10 +1807,12 @@ export function buildExternalActions(unitResults, resolvedVersions, productionAs
           .replaceAll('{version}', unitVersion)
           .replaceAll('{unit}', unit.id),
         notes: unit.production?.releaseNotes ?? `Release ${resolvedTag}`,
+        ...(releaseAssets ? { releaseAssets } : {}),
       },
       expected: {
         tag: resolvedTag,
         commit: asset.commit,
+        ...(releaseAssets ? { releaseAssetsDigest: digestReleaseAssetIdentities(releaseAssets) } : {}),
       },
       status: 'PENDING',
     });
@@ -3648,7 +3655,68 @@ export async function prepareRelease(options) {
     // 构建冻结分发映射：unitId -> frozen distributions
     const frozenDistributionsMap = new Map(units.map((u) => [u.id, u.distributions]));
 
-    let externalActions = buildExternalActions(unitResults, resolvedVersions, productionAssets, externalMarketplaceFreezes, frozenDistributionsMap);
+    let publicSourceAuthorityReceipt = null;
+    if (config.publicSourceAuthorityReceipt) {
+      if (!production || !sourceAuthority) {
+        throw new ReleaseError(
+          CONFIG_INVALID,
+          'publicSourceAuthorityReceipt requires a production prepare with source-authority closure enabled',
+        );
+      }
+      const unitsById = new Map(units.map((unit) => [unit.id, unit]));
+      const subjects = config.publicSourceAuthorityReceipt.subjectUnitIds.map((unitId) => {
+        const unit = unitsById.get(unitId);
+        const npmDistribution = unit?.distributions?.find((distribution) => distribution.type === 'npm');
+        const npm = unit?.frozenSnapshot?.npm;
+        if (!unit || !npmDistribution || !npm) {
+          throw new ReleaseError(
+            GATE_FAILED,
+            `public source-authority subject unit "${unitId}" is missing its frozen npm tarball`,
+          );
+        }
+        return {
+          packageName: npmDistribution.package,
+          version: unit.targetVersion,
+          filename: basename(npm.tarballPath),
+          sha256: npm.tarballSha256,
+        };
+      });
+      const builtReceipt = createPublicSourceAuthorityReceipt({
+        sourceRepository: sourceAuthority.sourceRepository,
+        sourceBaseCommit: baseline.gitHead,
+        subjects,
+      });
+      const assetName = 'source-authority-receipt.json';
+      const assetDirectory = resolve(runDir, 'release-assets');
+      await mkdir(assetDirectory, { recursive: true });
+      await writeFileAtomic(assetDirectory, assetName, builtReceipt.bytes, { mode: 0o644 });
+      publicSourceAuthorityReceipt = {
+        coordinatorUnitId: config.publicSourceAuthorityReceipt.coordinatorUnitId,
+        subjectUnitIds: [...config.publicSourceAuthorityReceipt.subjectUnitIds],
+        asset: {
+          name: assetName,
+          path: relative(realRoot, resolve(assetDirectory, assetName)),
+          sha256: builtReceipt.sha256,
+        },
+      };
+      await evidence.append({
+        phase: 'public-source-authority-receipt',
+        status: 'frozen',
+        coordinatorUnitId: publicSourceAuthorityReceipt.coordinatorUnitId,
+        subjectUnitIds: publicSourceAuthorityReceipt.subjectUnitIds,
+        assetPath: publicSourceAuthorityReceipt.asset.path,
+        assetSha256: publicSourceAuthorityReceipt.asset.sha256,
+      });
+    }
+
+    let externalActions = buildExternalActions(
+      unitResults,
+      resolvedVersions,
+      productionAssets,
+      externalMarketplaceFreezes,
+      frozenDistributionsMap,
+      publicSourceAuthorityReceipt,
+    );
 
     // Compute overall snapshot digest
     const overallSnapshotDigest = sha256Hex(snapshotDigests.join(':'));
@@ -3823,6 +3891,7 @@ export async function prepareRelease(options) {
       } : {}),
       units,
       externalActions,
+      ...(publicSourceAuthorityReceipt ? { publicSourceAuthorityReceipt } : {}),
       ...(frozenPostPublish ? { postPublish: frozenPostPublish } : {}),
       ...(sourceAuthority ? { sourceAuthority } : {}),
       createdAt: production ? createdAtTimestamp : (clock ? clock() : new Date().toISOString()),

package/src/commands/publish.mjs

@@ -61,6 +61,7 @@ import {
   GATE_FAILED,
   CONFIG_MISSING,
   BASELINE_CHANGED,
+  CONTENT_MISMATCH,
   PARTIAL_RELEASE,
   CONSUMER_VERIFICATION_DEFERRED,
 } from '../core/errors.mjs';
@@ -78,6 +79,7 @@ import {
   verifyFrozenSnapshot,
 } from '../snapshot/frozen.mjs';
 import { verifyFrozenNpmTarballContract } from '../adapters/npm.mjs';
+import { normalizeReleaseAssets } from '../core/release-assets.mjs';
 
 function assertInsideAssetRoot(assetRoot, candidate, label) {
   const rel = relative(assetRoot, candidate);
@@ -608,6 +610,17 @@ export async function publishRelease(options) {
           }, root);
         }
       }
+      for (const action of plan.externalActions ?? []) {
+        for (const releaseAsset of normalizeReleaseAssets(action.parameters?.releaseAssets)) {
+          const verifiedAsset = await verifyFrozenFile({
+            root,
+            filePath: releaseAsset.path,
+            expectedSha256: releaseAsset.sha256,
+            label: `frozen GitHub Release asset "${releaseAsset.name}"`,
+          });
+          assertInsideAssetRoot(assetRoot, verifiedAsset.physical, 'frozen GitHub Release asset');
+        }
+      }
       await evidence.append({ phase: 'safety-gate', gate: 'frozen-artifacts', status: 'passed' });
     }
 
@@ -987,6 +1000,29 @@ export async function publishRelease(options) {
         );
       }
 
+      if (
+        plan.publicSourceAuthorityReceipt
+        && remoteResult.observation?.observedCommit !== plan.baseline.headCommit
+      ) {
+        const observedCommit = remoteResult.observation?.observedCommit ?? null;
+        await evidence.append({
+          phase: 'safety-gate',
+          gate: 'source-authority',
+          status: 'failed',
+          expectedCommit: plan.baseline.headCommit,
+          observedCommit,
+        });
+        throw new ReleaseError(
+          CONTENT_MISMATCH,
+          'source authority commit gate failed: remote observedCommit does not match the public receipt sourceBaseCommit',
+          {
+            gate: 'source-authority',
+            expectedCommit: plan.baseline.headCommit,
+            observedCommit,
+          },
+        );
+      }
+
       // Create receipt for successful verification
       sourceAuthorityReceipt = createSourceAuthorityReceipt({
         plan,

package/src/commands/verify.mjs

@@ -46,7 +46,11 @@ import {
   POST_PUBLISH_VERIFY_FAILED,
   CONSUMER_VERIFICATION_DEFERRED,
 } from '../core/errors.mjs';
-import { verifySourceAuthorityReceipt } from '../core/source-authority.mjs';
+import {
+  consumePublicSourceAuthorityReceipt,
+  verifySourceAuthorityReceipt,
+} from '../core/source-authority.mjs';
+import { verifyFrozenFile } from '../snapshot/frozen.mjs';
 import {
   deriveBaselineAdvances,
   applyBaselineAdvances,
@@ -61,6 +65,7 @@ import {
   normalizeRegistry,
   registryTokenKey,
   resolveNpmRegistryAuthToken,
+  verifyFrozenNpmTarballContract,
 } from '../adapters/npm.mjs';
 import { runConsumerVerificationGates } from '../core/verification-gates.mjs';
 import {
@@ -109,6 +114,40 @@ export const VERIFICATION_RESOLVED_TYPES = Object.freeze({
   NOT_REQUIRED_UNCHANGED: 'NOT_REQUIRED_UNCHANGED',
 });
 
+/** Re-read every frozen subject tarball before consuming the public receipt. */
+export async function verifyPublicSourceAuthorityReceiptOffline({ plan, root }) {
+  const descriptor = plan.publicSourceAuthorityReceipt;
+  const verifiedAsset = await verifyFrozenFile({
+    root,
+    filePath: descriptor.asset.path,
+    expectedSha256: descriptor.asset.sha256,
+    label: 'public source-authority receipt',
+  });
+  const actualSubjects = [];
+  for (const unitId of descriptor.subjectUnitIds) {
+    const unit = plan.units.find((candidate) => candidate.id === unitId);
+    const npmDistribution = unit?.distributions?.find((distribution) => distribution.type === 'npm');
+    const npm = unit?.frozenSnapshot?.npm;
+    await verifyFrozenNpmTarballContract({
+      package: npmDistribution?.package,
+      version: unit?.targetVersion,
+      tarballPath: npm?.tarballPath,
+      tarballSha256: npm?.tarballSha256,
+      integrity: npm?.integrity,
+    }, root);
+    actualSubjects.push({
+      packageName: npmDistribution.package,
+      version: unit.targetVersion,
+      filename: basename(npm.tarballPath),
+      sha256: npm.tarballSha256,
+    });
+  }
+  return consumePublicSourceAuthorityReceipt(
+    await readFile(verifiedAsset.physical),
+    actualSubjects,
+  );
+}
+
 /**
  * Map plan action type to adapter ActionType.
  * Must match publish.mjs and reconcile.mjs.
@@ -1689,6 +1728,19 @@ export async function verifyRelease(options) {
 
     await evidence.append({ phase: 'verify', step: 'adapter-verify', status: 'completed' });
 
+    if (plan.publicSourceAuthorityReceipt) {
+      const consumed = await verifyPublicSourceAuthorityReceiptOffline({ plan, root });
+      await evidence.append({
+        phase: 'public-source-authority-receipt',
+        status: 'passed',
+        verificationMode: 'offline-consumer',
+        sourceRepository: consumed.sourceRepository,
+        sourceBaseCommit: consumed.sourceBaseCommit,
+        subjectCount: consumed.subjects.length,
+        assetSha256: consumed.sha256,
+      });
+    }
+
     // =======================================================================
     // Step 4: Installation smoke test
     // =======================================================================