release-skill 0.2.5 → 0.2.7

package/src/commands/prepare.mjs

@@ -49,10 +49,16 @@ import {
   normalizeGitTimestamp,
   sealFrozenSnapshot,
 } from '../snapshot/frozen.mjs';
-import { ReleaseError, GATE_FAILED, CONFIG_INVALID, FORBIDDEN_CONTENT_DETECTED, RELEASE_DOCS_STALE } from '../core/errors.mjs';
+import { ReleaseError, GATE_FAILED, CONFIG_INVALID, CONFIG_MISSING, FORBIDDEN_CONTENT_DETECTED, RELEASE_DOCS_STALE, DIRTY_SOURCE_INPUT } from '../core/errors.mjs';
+import {
+  SOURCE_INPUT_ALGORITHM_VERSION,
+  computeSourceInputClosure,
+  checkSourceInputDirty,
+  verifySnapshotSourcesMatchClosure,
+} from '../core/source-authority.mjs';
 import { acquireProjectLock } from '../artifacts/project-lock.mjs';
 import { assertPreviousPublicBaselineTarget, observePreviousPublicBaseline } from '../core/previous-public-baseline.mjs';
-import { verifyFrozenNpmTarballIdentity } from '../adapters/npm.mjs';
+import { verifyFrozenNpmTarballContract } from '../adapters/npm.mjs';
 import { createProductionPrepareRunDir } from '../core/run.mjs';
 import { PLATFORMS } from '../platforms/registry.mjs';
 import { validateMarketplaceSourceSelection, MARKETPLACE_SOURCE_TYPES, resolvePluginManifestFromMarketplaceEntrySource, resolveMarketplaceRoot } from '../adapters/plugin-marketplace.mjs';
@@ -924,13 +930,13 @@ async function buildProductionAssets(
         tarballDir: resolveUnitScopedPath(resolve(runDir, 'tarballs'), unit.id),
         expectedSnapshotDigest: sealed.digest,
       });
-      await verifyFrozenNpmTarballIdentity({
+      await verifyFrozenNpmTarballContract({
         package: npmDistribution.package,
         version,
         tarballPath: relative(root, npm.tarballPath),
         tarballSha256: npm.sha256,
         integrity: npm.integrity,
-      }, root);
+      }, root, resolveUnitScopedPath(resolve(runDir, 'tarballs'), unit.id));
     }
 
     assets.push({
@@ -1919,6 +1925,87 @@ export async function prepareRelease(options) {
       });
     }
 
+    // --- Step 3c: Source authority content closure gate ---
+    // After hooks complete, compute the deterministic source-input closure
+    // and verify that closure inputs are clean (no staged/unstaged/untracked
+    // changes). Production configs must declare sourceRepository.
+    const sourceRepository = config.project?.sourceRepository ?? null;
+    const configDefaultBranch = config.project?.defaultBranch ?? null;
+
+    let sourceAuthority = null;
+    let sourceInputClosure = null;
+    if (production) {
+      if (!sourceRepository || typeof sourceRepository !== 'string') {
+        throw new ReleaseError(
+          CONFIG_MISSING,
+          'production prepare requires project.sourceRepository in configuration; source authority content gate needs a workspace source repository',
+          { configPath },
+        );
+      }
+
+      await evidence.append({ phase: 'source-authority', status: 'started' });
+
+      // Compute source-input closure from resolved unit configs
+      const unitConfigsForClosure = configUnits.map((unit, idx) => ({
+        ...unit,
+        version: { ...unit.version },
+      }));
+      sourceInputClosure = await computeSourceInputClosure({
+        units: unitConfigsForClosure,
+        root: realRoot,
+      });
+
+      await evidence.append({
+        phase: 'source-authority',
+        step: 'closure-computed',
+        entryCount: sourceInputClosure.entries.length,
+        inputDigest: sourceInputClosure.digest,
+      });
+
+      // Check only closure inputs for dirty (not whole workspace)
+      const dirtyResult = await checkSourceInputDirty({
+        closure: sourceInputClosure,
+        root: realRoot,
+      });
+      if (dirtyResult.dirty) {
+        await evidence.append({
+          phase: 'source-authority',
+          status: 'blocking',
+          reason: 'DIRTY_SOURCE_INPUT',
+          dirtyPaths: dirtyResult.dirtyPaths,
+        });
+        throw new ReleaseError(
+          DIRTY_SOURCE_INPUT,
+          `source-input closure files have uncommitted changes: ${dirtyResult.dirtyPaths.join(', ')}`,
+          { dirtyPaths: dirtyResult.dirtyPaths },
+        );
+      }
+
+      await evidence.append({
+        phase: 'source-authority',
+        step: 'dirty-check',
+        status: 'clean',
+      });
+
+      // Build sourceAuthority binding for plan digest
+      sourceAuthority = {
+        sourceRepository,
+        defaultBranch: configDefaultBranch,
+        entries: sourceInputClosure.entries,
+        inputDigest: sourceInputClosure.digest,
+        algorithmVersion: SOURCE_INPUT_ALGORITHM_VERSION,
+      };
+
+      await evidence.append({
+        phase: 'source-authority',
+        status: 'completed',
+        sourceRepository,
+        defaultBranch: configDefaultBranch,
+        inputDigest: sourceInputClosure.digest,
+        remoteObservation: offline ? 'unobserved-offline' : 'deferred-to-publish',
+      });
+    }
+
     // --- Step 4: Capture Git baseline (AFTER hooks, so workspaceDigest
     //     reflects any file changes introduced by hooks) ---
     await evidence.append({ phase: 'baseline', status: 'started' });
@@ -2183,6 +2270,75 @@ export async function prepareRelease(options) {
       gateCount: snapshotGateResults.length,
     });
 
+    // Bind the remote source-authority proof to the exact bytes that entered
+    // the frozen snapshots, not merely to an earlier read of the workspace.
+    // Then re-read the complete closure and dirty state once more so version
+    // sources and non-snapshot closure entries cannot drift during prepare.
+    if (production) {
+      const snapshotSourceResult = verifySnapshotSourcesMatchClosure({
+        closure: sourceInputClosure,
+        unitResults,
+      });
+      if (!snapshotSourceResult.passed) {
+        throw new ReleaseError(
+          DIRTY_SOURCE_INPUT,
+          'source inputs changed between closure calculation and frozen snapshot construction',
+          {
+            reason: 'SNAPSHOT_SOURCE_DRIFT',
+            dirtyPaths: snapshotSourceResult.error.paths,
+          },
+        );
+      }
+
+      const finalClosure = await computeSourceInputClosure({
+        units: configUnits,
+        root: realRoot,
+      });
+      if (finalClosure.digest !== sourceInputClosure.digest) {
+        const initialByPath = new Map(
+          sourceInputClosure.entries.map((entry) => [entry.path, entry]),
+        );
+        const finalByPath = new Map(
+          finalClosure.entries.map((entry) => [entry.path, entry]),
+        );
+        const changedPaths = [...new Set([
+          ...sourceInputClosure.entries.map((entry) => entry.path),
+          ...finalClosure.entries.map((entry) => entry.path),
+        ])].filter((path) => (
+          JSON.stringify(initialByPath.get(path) ?? null)
+          !== JSON.stringify(finalByPath.get(path) ?? null)
+        )).sort();
+        throw new ReleaseError(
+          DIRTY_SOURCE_INPUT,
+          'source-input closure changed while preparing frozen snapshots',
+          { reason: 'SOURCE_CLOSURE_DRIFT', dirtyPaths: changedPaths },
+        );
+      }
+
+      const finalDirtyResult = await checkSourceInputDirty({
+        closure: finalClosure,
+        root: realRoot,
+      });
+      if (finalDirtyResult.dirty) {
+        throw new ReleaseError(
+          DIRTY_SOURCE_INPUT,
+          `source-input closure files have uncommitted changes after snapshot construction: ${finalDirtyResult.dirtyPaths.join(', ')}`,
+          {
+            reason: 'DIRTY_AFTER_SNAPSHOT',
+            dirtyPaths: finalDirtyResult.dirtyPaths,
+          },
+        );
+      }
+
+      await evidence.append({
+        phase: 'source-authority',
+        step: 'snapshot-binding',
+        status: 'completed',
+        inputDigest: sourceInputClosure.digest,
+        snapshotSourceCount: snapshotSourceResult.observation.snapshotSourceCount,
+      });
+    }
+
     // --- Step 6: Remote uniqueness (deferred to publish preflight) ---
     // Prepare only observes the previous public baseline (already done above).
     // Remote uniqueness checks (tag, GitHub Release, npm version) are deferred
@@ -2665,6 +2821,7 @@ export async function prepareRelease(options) {
       } : {}),
       units,
       externalActions,
+      ...(sourceAuthority ? { sourceAuthority } : {}),
       createdAt: production ? createdAtTimestamp : (clock ? clock() : new Date().toISOString()),
     };
 

package/src/commands/publish.mjs

@@ -59,10 +59,15 @@ import { appendRunState, createProductionRunDir, writeRunAtomic, resolveDefaultR
 import {
   ReleaseError,
   GATE_FAILED,
+  CONFIG_MISSING,
   BASELINE_CHANGED,
   PARTIAL_RELEASE,
   CONSUMER_VERIFICATION_DEFERRED,
 } from '../core/errors.mjs';
+import {
+  verifyRemoteSourceContent,
+  createSourceAuthorityReceipt,
+} from '../core/source-authority.mjs';
 import { assertTransition, PUBLISHING, PUBLISHED, PARTIAL } from '../core/state-machine.mjs';
 import { matchObservation } from '../adapters/contract.mjs';
 import { observeWithRetry, clampPolicyToTimeout, DEFAULT_OBSERVE_RETRY_POLICY, isPropagatingMissing } from '../core/observe-retry.mjs';
@@ -72,7 +77,7 @@ import {
   verifyFrozenGitRepository,
   verifyFrozenSnapshot,
 } from '../snapshot/frozen.mjs';
-import { verifyFrozenNpmTarballIdentity } from '../adapters/npm.mjs';
+import { verifyFrozenNpmTarballContract } from '../adapters/npm.mjs';
 
 function assertInsideAssetRoot(assetRoot, candidate, label) {
   const rel = relative(assetRoot, candidate);
@@ -527,6 +532,13 @@ export async function publishRelease(options) {
     if (productionMode && !isProductionPlan) {
       throw new ReleaseError(GATE_FAILED, 'production publish requires a github-npm-v1 frozen plan');
     }
+    if (isProductionPlan && !plan.sourceAuthority) {
+      throw new ReleaseError(
+        CONFIG_MISSING,
+        'production publish requires a frozen sourceAuthority binding; re-run prepare with project.sourceRepository configured',
+        { gate: 'source-authority' },
+      );
+    }
     const verifiedFrozenSnapshots = new Map();
     if (isProductionPlan) {
       if (!plan.production.assetRoot || plan.production.assetRoot === '.') {
@@ -595,7 +607,7 @@ export async function publishRelease(options) {
           if (!npmDistribution) {
             throw new ReleaseError(GATE_FAILED, `unit "${unit.id}" has a frozen npm tarball but no npm distribution`);
           }
-          await verifyFrozenNpmTarballIdentity({
+          await verifyFrozenNpmTarballContract({
             package: npmDistribution.package,
             version: unit.targetVersion,
             tarballPath: frozen.npm.tarballPath,
@@ -932,6 +944,65 @@ export async function publishRelease(options) {
       }
     }
 
+    // =======================================================================
+    // Safety Gate 11: Source authority content closure verification
+    // Verifies that the frozen source-input closure content exists in the
+    // workspace's remote default branch. Must pass before ANY adapter execute.
+    // Failure => zero adapter execute calls.
+    // =======================================================================
+    let sourceAuthorityReceipt = null;
+    if (plan.sourceAuthority) {
+      await evidence.append({ phase: 'safety-gate', gate: 'source-authority', status: 'started' });
+
+      const sa = plan.sourceAuthority;
+
+      // Verify the remote source tree against the entries frozen into the
+      // digest-bound plan. Publish must never rebuild authority from the
+      // mutable workspace or current config.
+      const frozenClosure = {
+        algorithmVersion: sa.algorithmVersion,
+        digest: sa.inputDigest,
+        entries: sa.entries,
+      };
+      const remoteResult = await verifyRemoteSourceContent({
+        sourceRepository: sa.sourceRepository,
+        defaultBranch: sa.defaultBranch,
+        closure: frozenClosure,
+        readRemoteFn: options.readRemoteSourceFn,
+      });
+
+      if (!remoteResult.passed) {
+        const errorCode = remoteResult.error?.code ?? GATE_FAILED;
+        await evidence.append({
+          phase: 'safety-gate',
+          gate: 'source-authority',
+          status: 'failed',
+          error: remoteResult.error,
+        });
+        throw new ReleaseError(
+          errorCode,
+          `source authority content gate failed: ${remoteResult.error?.message}`,
+          remoteResult.error,
+        );
+      }
+
+      // Create receipt for successful verification
+      sourceAuthorityReceipt = createSourceAuthorityReceipt({
+        plan,
+        result: 'CONSISTENT',
+        observation: remoteResult.observation,
+        clock: clockFn,
+      });
+
+      await evidence.append({
+        phase: 'safety-gate',
+        gate: 'source-authority',
+        status: 'passed',
+        sourceRepository: sa.sourceRepository,
+        defaultBranch: sa.defaultBranch,
+      });
+    }
+
     // =======================================================================
     // All safety gates passed -- prepare for execution
     // =======================================================================
@@ -1069,6 +1140,7 @@ export async function publishRelease(options) {
           : {}),
       })),
       startedAt,
+      ...(sourceAuthorityReceipt ? { sourceAuthorityReceipts: [sourceAuthorityReceipt] } : {}),
       ...(finishedAt ? { finishedAt } : {}),
     });
     let stateSequence = 0;

package/src/commands/reconcile.mjs

@@ -59,8 +59,10 @@ import {
   CONSUMER_VERIFICATION_DEFERRED,
 } from '../core/errors.mjs';
 import { assertTransition, PARTIAL, PUBLISHED, BLOCKED } from '../core/state-machine.mjs';
+import { verifySourceAuthorityReceipt } from '../core/source-authority.mjs';
 import { matchObservation } from '../adapters/contract.mjs';
 import { observeWithRetry, clampPolicyToTimeout, DEFAULT_OBSERVE_RETRY_POLICY } from '../core/observe-retry.mjs';
+import { verifyFrozenNpmTarballContract } from '../adapters/npm.mjs';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -209,6 +211,44 @@ export async function reconcileRelease(options) {
 
     await evidence.append({ phase: 'safety-gate', gate: 'action-completeness', status: 'passed' });
 
+    // =======================================================================
+    // Safety Gate 2c: Unconditional frozen npm entry-closure recheck
+    // This is plan-global and intentionally precedes source-run observation:
+    // a previously consistent npm checkpoint must not exempt a bad frozen
+    // tarball while another action is being reconciled.
+    // =======================================================================
+    for (const unit of plan.units ?? []) {
+      const frozen = unit.frozenSnapshot;
+      if (!frozen?.npm) continue;
+      const npmDistribution = (unit.distributions ?? []).find((distribution) => distribution.type === 'npm');
+      if (!npmDistribution) {
+        throw new ReleaseError(
+          GATE_FAILED,
+          `unit "${unit.id}" has a frozen npm tarball but no npm distribution`,
+          { gate: 'npm-entry-closure', unitId: unit.id },
+        );
+      }
+      await evidence.append({
+        phase: 'safety-gate',
+        gate: 'npm-entry-closure',
+        unitId: unit.id,
+        status: 'started',
+      });
+      await verifyFrozenNpmTarballContract({
+        package: npmDistribution.package,
+        version: unit.targetVersion,
+        tarballPath: frozen.npm.tarballPath,
+        tarballSha256: frozen.npm.tarballSha256,
+        integrity: frozen.npm.integrity,
+      }, root);
+      await evidence.append({
+        phase: 'safety-gate',
+        gate: 'npm-entry-closure',
+        unitId: unit.id,
+        status: 'passed',
+      });
+    }
+
     // =======================================================================
     // Safety Gate 3: Load and validate source run
     // =======================================================================
@@ -233,6 +273,18 @@ export async function reconcileRelease(options) {
         `reconcile source command must be publish or reconcile, got "${sourceRun.command}"`,
       );
     }
+    let sourceAuthorityReceipt = null;
+    if (plan.sourceAuthority) {
+      const receiptResult = verifySourceAuthorityReceipt({ plan, run: sourceRun });
+      if (!receiptResult.passed) {
+        throw new ReleaseError(
+          GATE_FAILED,
+          `reconcile source run has no valid source-authority receipt: ${receiptResult.reason}`,
+          { gate: 'source-authority', sourceRunId: sourceRun.runId },
+        );
+      }
+      sourceAuthorityReceipt = receiptResult.receipt;
+    }
 
     let consumedApprovalPath = sourceRun.approvalPath;
     let consumedApprovalDigest = sourceRun.approvalDigest;
@@ -956,6 +1008,9 @@ export async function reconcileRelease(options) {
       sourceRunDigest: sourceAuthorityDigest,
       sourceRunPath,
       status,
+      ...(sourceAuthorityReceipt
+        ? { sourceAuthorityReceipts: [sourceAuthorityReceipt] }
+        : {}),
       checkpoints: planActions.map((action) => {
         const value = actionResults.get(action.id);
         const normalized = value === 'deferred' ? 'deferred'
@@ -1303,6 +1358,9 @@ export async function reconcileRelease(options) {
       sourceRunDigest,
       sourceRunPath,
       status: overallStatus,
+      ...(sourceAuthorityReceipt
+        ? { sourceAuthorityReceipts: [sourceAuthorityReceipt] }
+        : {}),
       checkpoints: planActions.map((a) => {
         const status = actionResults.get(a.id) ?? 'pending';
         const normalized = status === 'deferred' ? 'deferred'