release-skill 0.8.0 → 0.8.1

package/bin/rules.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "kind": "skill-family.contracts.rules",
-  "contractsVersion": "1.12.0",
+  "contractsVersion": "1.13.0",
   "budget": {
     "firstVersionMax": 20,
     "absoluteMax": 30,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "release-skill",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Safe preparation and frozen GitHub/npm production publishing with full happy end verification",
   "author": {
     "name": "广州市风荷科技有限公司"
@@ -79,9 +79,9 @@
     "ajv-formats": "3.0.1",
     "libnpmpublish": "11.2.0",
     "npm-registry-fetch": "18.0.2",
-    "skill-family-contracts": "0.12.0",
-    "skill-family-engineering-kit": "0.12.0",
-    "skill-family-harness-node": "0.12.0",
+    "skill-family-contracts": "0.13.0",
+    "skill-family-engineering-kit": "0.13.0",
+    "skill-family-harness-node": "0.13.0",
     "yaml": "2.9.0"
   },
   "devDependencies": {

package/platform-manifest.json

@@ -2,11 +2,11 @@
   "schemaVersion": "1.0.0",
   "platformId": "release-skill",
   "platformName": "release-skill Plugin Platform",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "logicalRoot": "skills-src/",
   "logicalRootDigest": "3142e4454f192de6bb3de09141dfb7798a16acd3b8de820a70a2bf185f82fd38",
   "projectionDigest": "43e29d004faac5800912a95abc013690e72f5cfd3b42e33cbc28fef39a39bfa3",
-  "projectionId": "release-skill:platform:0.8.0",
+  "projectionId": "release-skill:platform:0.8.1",
   "manifestRequired": true,
   "projectionSources": {
     "skills-src-root": {

package/schemas/release-plan.schema.json

@@ -1051,9 +1051,10 @@
     "humanConsumersStrategy": {
       "type": "string",
       "enum": [
-        "manualFollowUps"
+        "manualFollowUps",
+        "foundationPayloadThenManualFollowUps"
       ],
-      "description": "Human consumer strategy marker. 'manualFollowUps': Kimi/CodeBuddy installations are non-blocking post-release manual tasks; verify returns VERIFIED with manualFollowUps list and does not block on attestation. Absent: legacy attestation closed loop (backward compatibility)."
+      "description": "Human consumer strategy marker. 'foundationPayloadThenManualFollowUps': verify first observes the complete frozen plugin through Foundation, then preserves non-blocking Kimi/CodeBuddy marketplace/invocation follow-ups. 'manualFollowUps': legacy 0.8 behavior without the Foundation payload observation. Absent: legacy attestation closed loop."
     },
     "workflowKind": {
       "type": "string",

package/schemas/release-run.schema.json

@@ -530,7 +530,7 @@
     },
     "manualFollowUps": {
       "type": "array",
-      "description": "Non-blocking manual follow-up tasks for human consumer platforms (Kimi/CodeBuddy) when plan declares humanConsumersStrategy: 'manualFollowUps'",
+      "description": "Non-blocking marketplace installation and invocation follow-ups for Kimi/CodeBuddy. Under foundationPayloadThenManualFollowUps, the frozen payload was observed first but these real-host tasks remain unverified.",
       "items": {
         "type": "object",
         "required": [
@@ -571,6 +571,40 @@
         }
       }
     },
+    "foundationPluginVerificationReceipts": {
+      "type": "array",
+      "description": "Foundation complete-plugin local payload observations bound to verify actions. These receipts do not prove marketplace installation or host invocation.",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "planDigest",
+          "actionId",
+          "unitId",
+          "requestDigest",
+          "hostId",
+          "goal",
+          "sourceType",
+          "foundationStatus",
+          "payloadMatches",
+          "observationDigest",
+          "observedAt"
+        ],
+        "properties": {
+          "planDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+          "actionId": { "type": "string", "minLength": 1 },
+          "unitId": { "type": "string", "minLength": 1 },
+          "requestDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+          "hostId": { "enum": ["kimi-code", "workbuddy"] },
+          "goal": { "const": "install-only" },
+          "sourceType": { "const": "local-staged" },
+          "foundationStatus": { "const": "observed" },
+          "payloadMatches": { "const": true },
+          "observationDigest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+          "observedAt": { "type": "string", "format": "date-time" }
+        }
+      }
+    },
     "skillResourceClosureReceipts": {
       "type": "array",
       "description": "Per-surface skill resource closure verification receipts from verify phase",

package/src/commands/prepare.mjs

@@ -58,6 +58,7 @@ import {
 import { ReleaseError, GATE_FAILED, CONFIG_INVALID, CONFIG_MISSING, FORBIDDEN_CONTENT_DETECTED, RELEASE_DOCS_STALE, DIRTY_SOURCE_INPUT, BUNDLE_STALE } from '../core/errors.mjs';
 import { assertBundleFreshness } from '../core/bundle-freshness.mjs';
 import { assertAdapterFreshness, assertSelfBootstrapFacts } from '../core/derived-artifact-gates.mjs';
+import { isFoundationPluginVerificationEligible } from '../core/foundation-plugin-verification.mjs';
 import { PKG_ROOT } from '../core/pkg-root.mjs';
 import { writeFrozenMarker, FROZEN_MARKER_FILENAME } from '../core/frozen-marker.mjs';
 import {
@@ -4235,11 +4236,21 @@ export async function prepareRelease(options) {
       });
     }
 
-    // Detect human consumer platforms (Kimi/CodeBuddy) in the plan.
-    // When present, new plans mark them as non-blocking manual follow-up tasks.
-    const hasHumanConsumerActions = externalActions.some(
+    // Detect human consumer platforms (Kimi/CodeBuddy) in the plan. Foundation
+    // 0.13 can observe their complete local payload only when production has
+    // frozen a bundled-family source. Standalone marketplace sources remain on
+    // the legacy manual-follow-up path because Foundation exposes no public
+    // Kimi/WorkBuddy public-channel driver in this release.
+    const humanConsumerActions = externalActions.filter(
       (a) => a.type === 'kimi-marketplace-install' || a.type === 'codebuddy-marketplace-install',
     );
+    const humanConsumersStrategy = humanConsumerActions.length === 0
+      ? null
+      : humanConsumerActions.some((action) => (
+          isFoundationPluginVerificationEligible({ action, units })
+        ))
+        ? 'foundationPayloadThenManualFollowUps'
+        : 'manualFollowUps';
 
     // --- Fold the validated postPublish declaration into the frozen plan ---
     // Bindings: tag (tagTemplate rendered at the resolved target version —
@@ -4331,7 +4342,7 @@ export async function prepareRelease(options) {
         : {}),
       verificationGates: config.verificationGates ?? [],
       snapshotDigest: overallSnapshotDigest,
-      ...(hasHumanConsumerActions ? { humanConsumersStrategy: 'manualFollowUps' } : {}),
+      ...(humanConsumersStrategy ? { humanConsumersStrategy } : {}),
       ...(production ? {
         production: {
           mode: 'github-npm-v1',

package/src/commands/verify.mjs

@@ -62,6 +62,10 @@ import {
 import { loadProjectConfig } from '../core/config.mjs';
 import { assertTransition, PUBLISHED, VERIFIED } from '../core/state-machine.mjs';
 import { clearFrozenMarker } from '../core/frozen-marker.mjs';
+import {
+  isFoundationPluginVerificationEligible,
+  verifyFrozenPluginWithFoundation,
+} from '../core/foundation-plugin-verification.mjs';
 import { resolveUnitScopedPath } from '../snapshot/public-path.mjs';
 import {
   normalizeRegistry,
@@ -944,6 +948,7 @@ export async function verifyRelease(options) {
     previousVerifyRun,
     execFn,
     configPath: configPathOpt,
+    runPluginVerificationFn,
   } = options ?? {};
 
   const clockFn = typeof clockOpt === 'function' ? clockOpt : defaultClock;
@@ -1351,10 +1356,15 @@ export async function verifyRelease(options) {
       }
     }
 
-    // When the plan declares humanConsumersStrategy: 'manualFollowUps',
-    // Kimi/CodeBuddy installations are non-blocking post-release manual tasks.
-    // Skip attestation collection and blocking for these platforms.
-    const isHumanConsumerFollowUp = plan.humanConsumersStrategy === 'manualFollowUps';
+    // Kimi/CodeBuddy remain non-blocking post-release manual tasks. New plans
+    // additionally require a Foundation observation of the complete frozen
+    // payload before the manual marketplace/invocation follow-up is emitted.
+    const isHumanConsumerFollowUp = [
+      'manualFollowUps',
+      'foundationPayloadThenManualFollowUps',
+    ].includes(plan.humanConsumersStrategy);
+    const requiresFoundationPayloadObservation = plan.humanConsumersStrategy
+      === 'foundationPayloadThenManualFollowUps';
 
     const missingManualAttestations = isHumanConsumerFollowUp
       ? []
@@ -1382,6 +1392,7 @@ export async function verifyRelease(options) {
 
     // Collect non-blocking manual follow-up tasks for human consumer platforms
     const manualFollowUps = [];
+    const foundationPluginVerificationReceipts = [];
 
     // Every action is identity-bound and adapters receive read-only or
     // per-action isolated consumer paths. Run independent checks concurrently;
@@ -1414,13 +1425,40 @@ export async function verifyRelease(options) {
       }
 
       if (isMarketplaceAction(action.type)) {
-        // When humanConsumersStrategy is 'manualFollowUps', Kimi/CodeBuddy
-        // installations are non-blocking manual follow-up tasks. Skip adapter
-        // processing and collect them as manualFollowUps.
+        // Both human-consumer strategies keep marketplace installation and
+        // invocation as non-blocking manual follow-ups. The new strategy first
+        // requires Foundation to observe the identity-bound frozen payload.
         const isHumanConsumerPlatform = action.type === 'kimi-marketplace-install'
           || action.type === 'codebuddy-marketplace-install';
         if (isHumanConsumerFollowUp && isHumanConsumerPlatform) {
           const platform = action.type === 'kimi-marketplace-install' ? 'kimi' : 'codebuddy';
+          const observesFoundationPayload = requiresFoundationPayloadObservation
+            && isFoundationPluginVerificationEligible({ action, units: plan.units });
+          if (observesFoundationPayload) {
+            const actionRunDir = join(runDir, 'foundation-plugin-verification', action.id);
+            await mkdir(join(actionRunDir, 'install'), { recursive: true, mode: 0o700 });
+            await mkdir(join(actionRunDir, 'temporary'), { recursive: true, mode: 0o700 });
+            await mkdir(join(actionRunDir, 'evidence'), { recursive: true, mode: 0o700 });
+            const receipt = await verifyFrozenPluginWithFoundation({
+              plan,
+              action,
+              root,
+              runDir: actionRunDir,
+              ...(runPluginVerificationFn ? { runPluginVerificationFn } : {}),
+              clock: clockFn,
+            });
+            foundationPluginVerificationReceipts.push(receipt);
+            await evidence.append({
+              phase: 'verify-marketplace',
+              actionId: action.id,
+              actionType: action.type,
+              status: 'FOUNDATION_PAYLOAD_OBSERVED',
+              requestDigest: receipt.requestDigest,
+              hostId: receipt.hostId,
+              payloadMatches: receipt.payloadMatches,
+              observationDigest: receipt.observationDigest,
+            });
+          }
           manualFollowUps.push({
             actionId: action.id,
             platform,
@@ -1428,20 +1466,26 @@ export async function verifyRelease(options) {
             version: action.parameters?.version,
             unitId: action.unitId,
             verifiedBySystem: false,
-            reason: 'human consumer platform — installation is a manual post-release task; not verified by system',
+            reason: observesFoundationPayload
+              ? 'complete frozen payload observed by Foundation; marketplace installation and host invocation remain manual'
+              : 'human consumer platform — installation is a manual post-release task; not verified by system',
           });
           adapterChecks.push({
             actionId: action.id,
             actionType: action.type,
             status: 'SKIPPED',
-            reason: 'manual-follow-up',
+            reason: observesFoundationPayload
+              ? 'foundation-payload-observed-manual-follow-up'
+              : 'manual-follow-up',
           });
           await evidence.append({
             phase: 'verify-marketplace',
             actionId: action.id,
             actionType: action.type,
             status: 'SKIPPED',
-            reason: 'manual-follow-up',
+            reason: observesFoundationPayload
+              ? 'foundation-payload-observed-manual-follow-up'
+              : 'manual-follow-up',
           });
           return;
         }
@@ -1727,6 +1771,8 @@ export async function verifyRelease(options) {
     }));
     adapterChecks.sort((a, b) => a.actionId.localeCompare(b.actionId));
     consumerVerificationReceipts.sort((a, b) => a.actionId.localeCompare(b.actionId));
+    foundationPluginVerificationReceipts.sort((a, b) => a.actionId.localeCompare(b.actionId));
+    manualFollowUps.sort((a, b) => a.actionId.localeCompare(b.actionId));
     consumerGateResults.sort((a, b) => a.id.localeCompare(b.id));
     const rejectedAction = actionResults.find((result) => result.status === 'rejected');
     if (rejectedAction) throw rejectedAction.reason;
@@ -2034,6 +2080,9 @@ export async function verifyRelease(options) {
       gateResults: consumerGateResults,
       consumerVerificationReceipts,
       skillResourceClosureReceipts,
+      ...(foundationPluginVerificationReceipts.length > 0
+        ? { foundationPluginVerificationReceipts }
+        : {}),
       ...(manualFollowUps.length > 0 ? { manualFollowUps } : {}),
       startedAt: clockFn(),
       finishedAt: clockFn(),
@@ -2132,6 +2181,9 @@ export async function verifyRelease(options) {
       recoveryActionCode: null,
       smokeTest,
       gateResults: consumerGateResults,
+      ...(foundationPluginVerificationReceipts.length > 0
+        ? { foundationPluginVerificationReceipts }
+        : {}),
       ...(manualFollowUps.length > 0 ? { manualFollowUps } : {}),
       ...(baselineAdvance ? { baselineAdvance } : {}),
     };

package/src/core/foundation-plugin-verification.mjs

@@ -0,0 +1,247 @@
+/**
+ * Release-domain thin adapter for Foundation 0.13 complete-plugin observation.
+ *
+ * The frozen snapshot remains the only payload authority. This module derives
+ * transient Foundation inputs from that tree, calls the released Kit API, and
+ * returns only the fields needed to bind the mechanism observation to a
+ * release action. It does not prove a marketplace install or host invocation.
+ *
+ * @module core/foundation-plugin-verification
+ */
+
+import { join } from 'node:path';
+
+import { digestDocument } from 'skill-family-contracts';
+import {
+  bundledHostProfilesRoot,
+  describeHost,
+  runPluginVerification,
+} from 'skill-family-engineering-kit';
+import {
+  createFilesystemRootBinding,
+  readFileBound,
+} from 'skill-family-harness-node';
+
+import { getPlatform, normalizeHostId } from '../platforms/registry.mjs';
+import { verifyFrozenSnapshot } from '../snapshot/frozen.mjs';
+import { ReleaseError, POST_PUBLISH_VERIFY_FAILED } from './errors.mjs';
+
+// Foundation's public plugin-verification request freezes the built-in driver
+// contract at 1.0.0. The real API integration test intentionally exercises
+// this value so an upstream contract change fails closed during adoption.
+const FOUNDATION_PLUGIN_DRIVER_VERSION = '1.0.0';
+
+function fail(message, details = {}) {
+  return new ReleaseError(POST_PUBLISH_VERIFY_FAILED, message, details);
+}
+
+function projectSourceMembers(entries) {
+  const directories = new Set();
+  for (const entry of entries) {
+    const parts = entry.path.split('/');
+    for (let count = 1; count < parts.length; count += 1) {
+      directories.add(parts.slice(0, count).join('/'));
+    }
+  }
+  return [
+    ...[...directories].map((path) => ({ path, type: 'directory' })),
+    ...entries.map((entry) => ({
+      path: entry.path,
+      type: 'file',
+      sha256: entry.contentDigest,
+      bytes: entry.size,
+      executable: (entry.mode & 0o111) !== 0,
+    })),
+  ].sort((left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0);
+}
+
+/**
+ * Return whether one human-consumer action has the complete frozen identity
+ * required by Foundation's local-staged plugin verification.
+ *
+ * This predicate is deliberately plan-derived. It does not persist a second
+ * action list, and the verifier repeats the same checks before every call.
+ */
+export function isFoundationPluginVerificationEligible({ action, units = [] } = {}) {
+  const platformId = action?.parameters?.consumer;
+  const expectedType = platformId === 'kimi'
+    ? 'kimi-marketplace-install'
+    : platformId === 'codebuddy'
+      ? 'codebuddy-marketplace-install'
+      : null;
+  if (!expectedType || action?.type !== expectedType) return false;
+
+  const unit = units.find((candidate) => candidate.id === action.unitId);
+  const snapshot = unit?.frozenSnapshot;
+  const sourceDescriptor = action.parameters?.sourceDescriptor;
+  if (
+    !snapshot?.path
+    || !snapshot.commit
+    || !snapshot.manifestDigest
+    || sourceDescriptor?.form !== 'bundled-family'
+    || sourceDescriptor.pluginSubpath !== '.'
+    || sourceDescriptor.commit !== snapshot.commit
+    || sourceDescriptor.payloadDigest !== snapshot.manifestDigest
+    || action.parameters?.sourceCommit !== snapshot.commit
+    || action.parameters?.snapshotPath !== snapshot.path
+    || action.parameters?.manifestDigest !== snapshot.manifestDigest
+  ) return false;
+
+  const platform = getPlatform(platformId);
+  return (unit.distributions ?? []).some((distribution) => (
+    distribution.type === platform.distributionType
+    && typeof distribution.installationContract?.manifestRelativePath === 'string'
+    && distribution.installationContract.manifestRelativePath.length > 0
+  ));
+}
+
+function assertResultMatchesRequest(result, request) {
+  if (
+    result?.status !== 'observed'
+    || result.requestDigest !== digestDocument(request)
+    || result.goal !== request.goal
+    || digestDocument(result.source) !== digestDocument(request.source)
+    || digestDocument(result.host) !== digestDocument(request.host)
+    || result.facts?.install?.payloadMatches !== true
+    || result.facts.install.sourceMode !== 'local-staged'
+    || result.facts.install.retained !== true
+    || result.facts.invocation !== null
+  ) {
+    throw fail('Foundation complete-plugin observation did not satisfy the frozen local payload contract', {
+      foundationStatus: result?.status ?? null,
+      foundationReason: result?.reason ?? null,
+      payloadMatches: result?.facts?.install?.payloadMatches ?? null,
+      requiredActions: result?.requiredActions ?? [],
+    });
+  }
+}
+
+/**
+ * Observe one frozen Kimi or CodeBuddy plugin payload through Foundation.
+ *
+ * @param {object} input
+ * @param {object} input.plan
+ * @param {object} input.action
+ * @param {string} input.root
+ * @param {string} input.runDir - Fresh per-action directory containing empty
+ *   install, temporary and evidence children.
+ * @param {Function} [input.runPluginVerificationFn]
+ * @param {Function} [input.clock]
+ * @returns {Promise<object>} local payload-observation receipt
+ */
+export async function verifyFrozenPluginWithFoundation({
+  plan,
+  action,
+  root,
+  runDir,
+  runPluginVerificationFn = runPluginVerification,
+  clock = () => new Date().toISOString(),
+} = {}) {
+  const unit = (plan?.units ?? []).find((candidate) => candidate.id === action?.unitId);
+  if (!unit?.frozenSnapshot?.path || !unit.frozenSnapshot.commit) {
+    throw fail('Foundation plugin observation requires a frozen unit snapshot', {
+      actionId: action?.id,
+      unitId: action?.unitId,
+    });
+  }
+
+  if (!isFoundationPluginVerificationEligible({ action, units: plan.units })) {
+    throw fail('Foundation local plugin observation requires one identity-bound bundled-family payload', {
+      actionId: action?.id,
+      sourceForm: action?.parameters?.sourceDescriptor?.form ?? null,
+      pluginSubpath: action?.parameters?.sourceDescriptor?.pluginSubpath ?? null,
+    });
+  }
+
+  const platformId = action?.parameters?.consumer;
+  const platform = getPlatform(platformId);
+  if (!['kimi', 'codebuddy'].includes(platform.id)) {
+    throw fail('Foundation local plugin observation is not configured for this release platform', {
+      actionId: action?.id,
+      platform: platform.id,
+    });
+  }
+  const sourceDescriptor = action.parameters.sourceDescriptor;
+  const distribution = (unit.distributions ?? []).find(
+    (candidate) => candidate.type === platform.distributionType,
+  );
+  const manifestRelativePath = distribution?.installationContract?.manifestRelativePath;
+  if (!manifestRelativePath) {
+    throw fail('Foundation plugin observation requires the frozen installation manifest path', {
+      actionId: action.id,
+      distributionType: platform.distributionType,
+    });
+  }
+
+  const frozen = await verifyFrozenSnapshot({
+    root,
+    snapshotPath: unit.frozenSnapshot.path,
+    expectedDigest: unit.frozenSnapshot.manifestDigest,
+  });
+  const sourceRoot = frozen.snapshotDir;
+  const sourceMembers = projectSourceMembers(frozen.entries);
+  const sourceManifest = frozen.entries.find((entry) => entry.path === manifestRelativePath);
+  if (!sourceManifest) {
+    throw fail('Foundation plugin observation manifest is not part of the frozen payload', {
+      actionId: action.id,
+      manifestRelativePath,
+    });
+  }
+
+  const hostsRoot = bundledHostProfilesRoot();
+  const hostId = await normalizeHostId(platform.buildAdapter.name);
+  const descriptor = await describeHost({ hostId, hostsRoot });
+  const hostsBinding = await createFilesystemRootBinding(hostsRoot);
+  const descriptorFile = await readFileBound(hostsRoot, `${hostId}/host-descriptor.json`, {
+    rootBinding: hostsBinding,
+  });
+  if (!descriptor.verification?.driverId) {
+    throw fail('Foundation host has no complete-plugin verification driver', { hostId });
+  }
+
+  const request = {
+    schemaVersion: 1,
+    kind: 'skill-family.plugin-verification-request',
+    operation: 'plugin-verification',
+    verificationSetId: `${plan.digest}:${action.id}`,
+    goal: 'install-only',
+    source: {
+      type: 'local-staged',
+      candidateRef: sourceDescriptor.commit,
+      sourceManifestSha256: sourceManifest.contentDigest,
+      membersDigest: digestDocument(sourceMembers),
+    },
+    host: {
+      hostId,
+      descriptorSha256: descriptorFile.sha256,
+      driverId: descriptor.verification.driverId,
+      driverVersion: FOUNDATION_PLUGIN_DRIVER_VERSION,
+    },
+    install: { mode: 'fresh-tree' },
+  };
+  const bindings = {
+    sourceRoot,
+    sourceManifestRelPath: manifestRelativePath,
+    sourceMembers,
+    installContainerRoot: join(runDir, 'install'),
+    temporaryRoot: join(runDir, 'temporary'),
+    privateEvidenceRoot: join(runDir, 'evidence'),
+  };
+
+  const result = await runPluginVerificationFn({ request, bindings, hostsRoot });
+  assertResultMatchesRequest(result, request);
+
+  return {
+    planDigest: plan.digest,
+    actionId: action.id,
+    unitId: unit.id,
+    requestDigest: result.requestDigest,
+    hostId,
+    goal: request.goal,
+    sourceType: request.source.type,
+    foundationStatus: result.status,
+    payloadMatches: result.facts.install.payloadMatches,
+    observationDigest: result.facts.install.observationDigest,
+    observedAt: clock(),
+  };
+}

package/src/core/skill-resource-closure.mjs

@@ -376,10 +376,14 @@ export function evaluateConsumerSkillResourceClosureReceipts(plan, receipts) {
     'kimi-plugin',
     'codebuddy-plugin',
   ]);
-  // When plan declares humanConsumersStrategy: 'manualFollowUps', Kimi/CodeBuddy
-  // are non-blocking manual follow-up tasks and are not verified by the system.
-  // Exclude them from the expected receipt set.
-  const humanConsumerTypes = plan.humanConsumersStrategy === 'manualFollowUps'
+  // Kimi/CodeBuddy remain non-blocking manual marketplace/invocation tasks in
+  // both strategy generations. The newer strategy adds a Foundation frozen
+  // payload observation but still does not establish an installed host
+  // surface, so these distributions stay outside this receipt set.
+  const humanConsumerTypes = [
+    'manualFollowUps',
+    'foundationPayloadThenManualFollowUps',
+  ].includes(plan.humanConsumersStrategy)
     ? new Set(['kimi-plugin', 'codebuddy-plugin'])
     : new Set();
   const expectedKeys = [];

package/src/producers/foundation-resource-projection.mjs

@@ -55,9 +55,9 @@ import { digestBytes, publishFileOrReplace, readFileStrict, withTemporaryWorkspa
 import { canonicalJson } from '../core/digest.mjs';
 
 export const FOUNDATION_PACKAGES = Object.freeze({
-  'skill-family-contracts': '0.12.0',
-  'skill-family-engineering-kit': '0.12.0',
-  'skill-family-harness-node': '0.12.0',
+  'skill-family-contracts': '0.13.0',
+  'skill-family-engineering-kit': '0.13.0',
+  'skill-family-harness-node': '0.13.0',
 });
 
 export const BINDING_RECORD_PATH = 'bin/foundation-resource-binding.json';

package/src/schemas/filesystem-tree-observation.schema.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.skill-family.example/v1/filesystem-tree-observation.json",
+  "title": "Filesystem tree observation",
+  "description": "A complete same-pass fact observation of a bound filesystem tree (FND-DES-014 section 6.1). Private data only: it is returned by the public read-only harness entry, but never enters a public plugin verification result. The record keeps the original root binding so consumers re-verify the same bound root and never re-bind a replacement. Members are canonical relative paths sorted by Unicode code point; directories carry identity/type/permission facts only; file bytes come from the same native descriptor that supplies statMode.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "kind", "rootBinding", "members", "membersDigest"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "kind": { "const": "skill-family.filesystem-tree-observation" },
+    "rootBinding": { "$ref": "https://contracts.skill-family.example/v1/filesystem-root-binding.json" },
+    "members": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "$ref": "#/$defs/member" }
+    },
+    "membersDigest": {
+      "type": "string",
+      "pattern": "^[0-9a-f]{64}$"
+    }
+  },
+  "$defs": {
+    "statMode": { "type": "integer", "minimum": 0, "maximum": 65535 },
+    "member": {
+      "oneOf": [
+        { "$ref": "#/$defs/fileMember" },
+        { "$ref": "#/$defs/directoryMember" }
+      ]
+    },
+    "fileMember": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["path", "type", "sha256", "bytes", "statMode", "contentBase64"],
+      "properties": {
+        "path": { "type": "string", "minLength": 1 },
+        "type": { "const": "file" },
+        "sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$" },
+        "bytes": { "type": "integer", "minimum": 0 },
+        "statMode": { "$ref": "#/$defs/statMode" },
+        "contentBase64": { "type": "string" }
+      }
+    },
+    "directoryMember": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["path", "type", "statMode"],
+      "properties": {
+        "path": { "type": "string", "minLength": 1 },
+        "type": { "const": "directory" },
+        "statMode": { "$ref": "#/$defs/statMode" }
+      }
+    }
+  }
+}

package/src/schemas/host-verification-result.schema.json

@@ -103,8 +103,8 @@
         "spawned": { "type": "boolean" },
         "exitStatus": { "type": ["integer", "null"], "minimum": 0 },
         "processStatus": { "type": ["string", "null"], "enum": ["PLANNED", "STARTING", "RUNNING", "EXITED", "FAILED_TO_START", "TIMED_OUT", "TERMINATED", null] },
-        "terminationReason": { "$ref": "https://contracts.skill-family.example/v1/watchdog-termination-envelope.json#/properties/terminationReason" },
-        "watchdogReason": { "$ref": "https://contracts.skill-family.example/v1/watchdog-termination-envelope.json#/properties/watchdogReason" },
+        "terminationReason": { "$ref": "https://contracts.skill-family.example/v1/watchdog-termination-envelope.json#/properties/terminationReason", "not": { "const": "output_limit_exceeded" } },
+        "watchdogReason": { "$ref": "https://contracts.skill-family.example/v1/watchdog-termination-envelope.json#/properties/watchdogReason", "not": { "const": "output_limit_exceeded" } },
         "runnerModelOverrideAbsent": { "type": "boolean" }
       }
     },