@kungfu-tech/buildchain 3.0.4-alpha.0 → 3.0.4-alpha.2

package/dist/site/buildchain-contract.json

@@ -4,7 +4,7 @@
   "product": {
     "name": "Buildchain",
     "package": "@kungfu-tech/buildchain",
-    "version": "3.0.4-alpha.0",
+    "version": "3.0.4-alpha.2",
     "repository": "https://github.com/kungfu-systems/buildchain"
   },
   "majorLine": "v3",
@@ -52,7 +52,7 @@
         "retryable GitHub fallback fetches use a bounded attempt budget before exact source SHA and tree verification"
       ],
       "breakingDigest": "sha256:dfbedd543ae0c067982b5c8c02d98dd2f7f7df88752be97fb330da6b0ba30faa",
-      "auditDigest": "sha256:8d0ef9c8048a107dc6fb418d93d9a799e27bf8f94dc008cbe4001255c54004f8"
+      "auditDigest": "sha256:5ae0793e1da87242a56d7fdf29a2d1d7d24ca50f68429797a7d78bcba605b797"
     },
     {
       "contractVersion": 1,
@@ -321,7 +321,7 @@
         "media qualification does not claim browser playback, responsive layout, reduced-motion behavior, accessibility, or production deployment"
       ],
       "breakingDigest": "sha256:425f8d3d1ba205dd6fe35a20f1dc6dad7d7c563872283e3af79fea4d5c475692",
-      "auditDigest": "sha256:38353cc5dc5520e6de84e387abafc6086a4b236e18be6521b00d43ad651582e4"
+      "auditDigest": "sha256:4f0051783d637ff25a1154379dc0eb77a246ad7aee18e12a5e8ff0107aa61a90"
     },
     {
       "contractVersion": 1,
@@ -731,7 +731,7 @@
         "agents can discover supported Node APIs without importing internal file paths"
       ],
       "breakingDigest": "sha256:48f925608d3e2131d90936b07dc2a30341204cae3e6e785c0f77d61ad755c945",
-      "auditDigest": "sha256:1a86c034cbe51c0da8ee978602f0f71e9e4faa5302a250b152c0d84d7d3a9f67"
+      "auditDigest": "sha256:db0fe262bcfc34ea78f8b9b36333b93ab9388548a46b4616b2105156b3f1173a"
     },
     {
       "contractVersion": 1,
@@ -1340,7 +1340,7 @@
         "missing receipts are non-qualifying and must not be represented as a successful controller run"
       ],
       "breakingDigest": "sha256:6b8d38e92b2c67b5bc83fae0a3fd95bfa47582fbc176e6cdeebe7630a57534cb",
-      "auditDigest": "sha256:8d0ef9c8048a107dc6fb418d93d9a799e27bf8f94dc008cbe4001255c54004f8"
+      "auditDigest": "sha256:5ae0793e1da87242a56d7fdf29a2d1d7d24ca50f68429797a7d78bcba605b797"
     },
     {
       "contractVersion": 1,
@@ -3522,5 +3522,5 @@
     }
   ],
   "compatibilityDigest": "sha256:61af7d0871220bc0909008bdc571905ad500cccf853e7841bc5d462a34b2d436",
-  "contractDigest": "sha256:72c454ef28010b660fc0caf1f4adc84e440a1edd1e8ebf6b8ece2e89563b1953"
+  "contractDigest": "sha256:52a759d10606f84efc0e1c25d5eb9afd4ad55835403d6a376a40dadd7f4648c4"
 }

package/dist/site/buildchain-site.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "contract": "kungfu-buildchain-site-bundle",
-  "generatedAt": "2026-08-01T00:11:51.140Z",
-  "publishedAt": "2026-08-01T00:11:51.140Z",
+  "generatedAt": "2026-08-01T01:21:41.151Z",
+  "publishedAt": "2026-08-01T01:21:41.151Z",
   "reproducible": true,
   "timestampPolicy": "ci-injected",
   "deterministicInputs": [
@@ -19,7 +19,7 @@
     "declared Buildchain surface manifest contract"
   ],
   "sourceDateEpoch": "0",
-  "sourceRevision": "72add9cc62566c1c1cbf3b1f01d2d4d2f74a2826",
+  "sourceRevision": "9e775fa1f698d857f8325c9c89777ea07ee98294",
   "timestampPolicyDetails": {
     "contract": "kungfu-buildchain-surface-timestamp-policy",
     "timestampFields": [
@@ -37,7 +37,7 @@
   },
   "package": {
     "name": "@kungfu-tech/buildchain",
-    "version": "3.0.4-alpha.0",
+    "version": "3.0.4-alpha.2",
     "versionSource": "package.json#version"
   },
   "source": {

package/dist/site/kfd-upstream-aggregate.json

@@ -4,7 +4,7 @@
   "product": {
     "id": "kungfu-tech-buildchain",
     "name": "@kungfu-tech/buildchain",
-    "version": "3.0.4-alpha.0",
+    "version": "3.0.4-alpha.2",
     "repository": "https://github.com/kungfu-systems/buildchain"
   },
   "source": {

package/dist/site/node-api-registry.json

@@ -616,7 +616,7 @@
       "specifier": "@kungfu-tech/buildchain/paper",
       "export": "./paper",
       "target": "./packages/core/paper.js",
-      "digest": "sha256:874ea983a1e4f7e9e7b04a122819d77945fa7968ebcea40ec231c0dcafd61ae1",
+      "digest": "sha256:5ccd8a5d3a8b77573ce1fefd12ff2850740df122aae5156f1eeaa943fc09fefc",
       "summary": "Unified Paper work, fleet, scaffold, preflight, npm bootstrap, build, Alpha, status, and resume planning APIs.",
       "capabilityGroup": "reusable-build",
       "audience": [

package/dist/site/publication-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "contract": "kungfu-buildchain-publication-release-registry",
-  "generatedAt": "2026-08-01T00:11:51.140Z",
-  "publishedAt": "2026-08-01T00:11:51.140Z",
+  "generatedAt": "2026-08-01T01:21:41.151Z",
+  "publishedAt": "2026-08-01T01:21:41.151Z",
   "reproducible": true,
   "timestampPolicy": "ci-injected",
   "deterministicInputs": [
@@ -19,7 +19,7 @@
     "declared Buildchain surface manifest contract"
   ],
   "sourceDateEpoch": "0",
-  "sourceRevision": "72add9cc62566c1c1cbf3b1f01d2d4d2f74a2826",
+  "sourceRevision": "9e775fa1f698d857f8325c9c89777ea07ee98294",
   "timestampPolicyDetails": {
     "contract": "kungfu-buildchain-surface-timestamp-policy",
     "timestampFields": [
@@ -32,7 +32,7 @@
   },
   "package": {
     "name": "@kungfu-tech/buildchain",
-    "version": "3.0.4-alpha.0",
+    "version": "3.0.4-alpha.2",
     "versionSource": "package.json#version"
   },
   "sourceKind": "package-site-bundle",

package/dist/site/site-manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "contract": "kungfu-buildchain-site-manifest",
-  "generatedAt": "2026-08-01T00:11:51.140Z",
-  "publishedAt": "2026-08-01T00:11:51.140Z",
+  "generatedAt": "2026-08-01T01:21:41.151Z",
+  "publishedAt": "2026-08-01T01:21:41.151Z",
   "reproducible": true,
   "timestampPolicy": "ci-injected",
   "deterministicInputs": [
@@ -19,7 +19,7 @@
     "declared Buildchain surface manifest contract"
   ],
   "sourceDateEpoch": "0",
-  "sourceRevision": "72add9cc62566c1c1cbf3b1f01d2d4d2f74a2826",
+  "sourceRevision": "9e775fa1f698d857f8325c9c89777ea07ee98294",
   "timestampPolicyDetails": {
     "contract": "kungfu-buildchain-surface-timestamp-policy",
     "timestampFields": [
@@ -37,7 +37,7 @@
   },
   "package": {
     "name": "@kungfu-tech/buildchain",
-    "version": "3.0.4-alpha.0",
+    "version": "3.0.4-alpha.2",
     "versionSource": "package.json#version"
   },
   "entrypoint": "buildchain-site.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kungfu-tech/buildchain",
-  "version": "3.0.4-alpha.0",
+  "version": "3.0.4-alpha.2",
   "private": false,
   "description": "Buildchain Release Passport, release governance, CLI toolkit, and site facts.",
   "repository": "https://github.com/kungfu-systems/buildchain",

package/packages/core/paper-fleet.js

@@ -1,10 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
-import { planPaperMigration, writePaperMigration } from "./paper.js";
+import {
+  planPaperMigration,
+  resolvePaperRuntimeGitSha,
+  writePaperMigration,
+} from "./paper.js";
 import {
   PAPER_PATHS,
   PAPER_WORK_BRANCH_PATTERN,
-  gitValue,
   paperWorkSource,
   readJson,
   rootedPlan,
@@ -188,7 +191,9 @@ export function collectPaperFleetAudit({
     root: resolvedRoot,
     runtime: {
       version: buildchainVersion,
-      sha: buildchainSha || gitValue(buildchainRoot, ["rev-parse", "HEAD"]),
+      sha:
+        buildchainSha ||
+        resolvePaperRuntimeGitSha(buildchainRoot, buildchainVersion),
     },
     summary: {
       repositories: entries.length,

package/packages/core/paper.js

@@ -35,6 +35,7 @@ import {
   PAPER_AGENT_ENTRY_CONTRACT,
   collectPaperAgentEntry,
   paperAgentEntryFiles,
+  resolvePaperBuildchainSha,
 } from "./paper-agent-entry.js";
 import {
   managedPaperPackageJson,
@@ -177,8 +178,11 @@ function buildchainPackageIdentity(buildchainRoot, explicitVersion = "") {
   };
 }
 
-function runtimeGitSha(buildchainRoot, buildchainVersion = "") {
-  const value = gitValue(buildchainRoot, ["rev-parse", "HEAD"]);
+export function resolvePaperRuntimeGitSha(
+  buildchainRoot,
+  buildchainVersion = "",
+) {
+  const value = resolvePaperBuildchainSha(buildchainRoot);
   if (GIT_SHA_PATTERN.test(value)) return value;
   const identity = buildchainPackageIdentity(buildchainRoot, buildchainVersion);
   if (!identity.version) return "";
@@ -661,7 +665,8 @@ export function planPaperScaffold({
     buildchainVersion,
   );
   const runtimeSha =
-    buildchainSha || runtimeGitSha(buildchainRoot, runtimeIdentity.version);
+    buildchainSha ||
+    resolvePaperRuntimeGitSha(buildchainRoot, runtimeIdentity.version);
   if (!GIT_SHA_PATTERN.test(runtimeSha)) {
     throw new Error(
       "paper scaffold cannot resolve the exact Buildchain runtime SHA; pass buildchainSha or use a published Buildchain package with npm gitHead provenance",
@@ -854,7 +859,8 @@ function migrationFiles({
     "paper publish package",
   );
   const runtimeSha =
-    buildchainSha || runtimeGitSha(buildchainRoot, buildchainVersion);
+    buildchainSha ||
+    resolvePaperRuntimeGitSha(buildchainRoot, buildchainVersion);
   if (!GIT_SHA_PATTERN.test(runtimeSha)) {
     throw new Error("paper migration requires an exact Buildchain source SHA");
   }
@@ -1734,7 +1740,8 @@ function runtimeFacts({
     version: identity.version,
     ref: buildchainRef,
     resolvedSha:
-      buildchainSha || runtimeGitSha(buildchainRoot, identity.version),
+      buildchainSha ||
+      resolvePaperRuntimeGitSha(buildchainRoot, identity.version),
     contract: contractWorld.contract,
     contractDigest: contractWorld.contractDigest,
     compatibilityDigest: contractWorld.compatibilityDigest,

package/scripts/aggregate-build-summary.mjs

@@ -8,6 +8,51 @@ function readEnv(name, fallback = "") {
   return process.env[name] || fallback;
 }
 
+function parsePlatformIds(name) {
+  const raw = readEnv(name, "").trim();
+  if (!raw) return [];
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error(`${name} must be a JSON array`);
+  }
+  const ids = parsed.map((entry) => String(
+    typeof entry === "string" ? entry : entry?.id || "",
+  ).trim());
+  if (ids.some((id) => !id)) {
+    throw new Error(`${name} entries must declare non-empty platform ids`);
+  }
+  if (new Set(ids).size !== ids.length) {
+    throw new Error(`${name} must not contain duplicate platform ids`);
+  }
+  return ids;
+}
+
+function readManifest(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function selectPlatformManifests({ inputRoot, expectedPlatformIds }) {
+  const candidates = findJsonFiles(inputRoot)
+    .filter((file) => path.basename(file) === "manifest.json")
+    .sort()
+    .map((file) => ({ file, manifest: readManifest(file) }))
+    .filter(({ manifest }) => manifest?.contract === "kungfu-buildchain-artifact");
+  if (expectedPlatformIds.length === 0) return candidates;
+  return expectedPlatformIds.map((platformId) => {
+    const matches = candidates.filter(({ manifest }) => manifest.platform?.id === platformId);
+    if (matches.length !== 1) {
+      throw new Error(
+        `expected exactly one platform manifest for ${platformId}, found ${matches.length} under ${inputRoot}`,
+      );
+    }
+    return matches[0];
+  });
+}
+
 export function aggregateBuildSummaryCli() {
   const inputRoot = path.resolve(readEnv("BUILDCHAIN_SUMMARY_INPUT", ".buildchain/downloaded-manifests"));
   const outputPath = path.resolve(readEnv("BUILDCHAIN_SUMMARY_OUTPUT", ".buildchain/artifacts/build-summary.json"));
@@ -18,10 +63,28 @@ export function aggregateBuildSummaryCli() {
     throw new Error("BUILDCHAIN_ADDITIONAL_PLATFORM_COUNT must be a non-negative integer");
   }
   const expectedManifestCount = expectedPlatformCount + additionalPlatformCount;
-  const manifestFiles = findJsonFiles(inputRoot)
-    .filter((file) => path.basename(file) === "manifest.json")
-    .sort();
-  const manifests = manifestFiles.map((file) => JSON.parse(fs.readFileSync(file, "utf8")));
+  const platformIds = parsePlatformIds("BUILDCHAIN_EXPECTED_PLATFORMS_JSON");
+  const additionalPlatformIds = parsePlatformIds("BUILDCHAIN_ADDITIONAL_PLATFORM_IDS_JSON");
+  if (platformIds.length > 0 && platformIds.length !== expectedPlatformCount) {
+    throw new Error(
+      `BUILDCHAIN_EXPECTED_PLATFORMS_JSON declares ${platformIds.length} platforms, expected ${expectedPlatformCount}`,
+    );
+  }
+  if (additionalPlatformIds.length !== additionalPlatformCount) {
+    throw new Error(
+      `BUILDCHAIN_ADDITIONAL_PLATFORM_IDS_JSON declares ${additionalPlatformIds.length} platforms, expected ${additionalPlatformCount}`,
+    );
+  }
+  const expectedPlatformIds = [...platformIds, ...additionalPlatformIds];
+  if (new Set(expectedPlatformIds).size !== expectedPlatformIds.length) {
+    throw new Error("declared platform ids must be unique across primary and additional platforms");
+  }
+  const selected = selectPlatformManifests({
+    inputRoot,
+    expectedPlatformIds,
+  });
+  const manifestFiles = selected.map(({ file }) => file);
+  const manifests = selected.map(({ manifest }) => manifest);
   if (expectedManifestCount > 0 && manifests.length !== expectedManifestCount) {
     throw new Error(
       `expected ${expectedManifestCount} platform manifests, found ${manifests.length} under ${inputRoot}`,

package/scripts/auditable-demo-renditions.mjs

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const TERMINAL_CAPTURE_NON_AUTHORITIES = [
+  "first-party-identity",
+  "system-identity",
+  "kfd-compliance",
+  "product-system-metadata",
+  "package-metadata",
+  "registry-history",
+  "scan-output",
+  "standalone-generation",
+];
+const RENDITION_SET_NON_AUTHORITIES = [
+  "publication-authority",
+  "runtime-authority",
+  ...TERMINAL_CAPTURE_NON_AUTHORITIES,
+];
+
+export function validateTerminalCapture(value, scene, helpers) {
+  const { decodeBase64, digestPattern, exactKeys, integer, invariant, maxBytes, maxEvents, text } = helpers;
+  exactKeys(
+    value,
+    ["schema", "command", "dimensions", "durationMs", "encoding", "events", "completion", "exitCode", "authority"],
+    [],
+    "terminalCapture",
+  );
+  invariant(value.schema === "kungfu.terminal-capture/v1", "unsupported terminal capture schema");
+  text(value.command, 1, 160, "terminalCapture.command");
+  exactKeys(value.dimensions, ["columns", "rows"], [], "terminalCapture.dimensions");
+  integer(value.dimensions.columns, 80, 200, "terminalCapture.dimensions.columns");
+  integer(value.dimensions.rows, 24, 80, "terminalCapture.dimensions.rows");
+  const durationMs = integer(value.durationMs, 500, 60000, "terminalCapture.durationMs");
+  invariant(
+    durationMs <= scene.durationMs && scene.durationMs - durationMs <= 2000,
+    "terminal capture duration must end within two seconds of the scene",
+  );
+  invariant(value.encoding === "base64", "terminalCapture.encoding must be base64");
+  invariant(
+    Array.isArray(value.events) && value.events.length > 0 && value.events.length <= maxEvents,
+    `terminalCapture.events must contain 1 through ${maxEvents} events`,
+  );
+  let previousAtMs = -1;
+  let totalBytes = 0;
+  for (const [index, event] of value.events.entries()) {
+    exactKeys(event, ["atMs", "data"], [], `terminalCapture.events[${index}]`);
+    const atMs = integer(event.atMs, 0, durationMs - 1, `terminalCapture.events[${index}].atMs`);
+    invariant(atMs >= previousAtMs, "terminal capture event timestamps must be monotonic");
+    invariant(index > 0 || atMs === 0, "the first terminal capture event must start at zero");
+    previousAtMs = atMs;
+    totalBytes += decodeBase64(event.data, `terminalCapture.events[${index}].data`).length;
+    invariant(totalBytes <= maxBytes, "terminal capture exceeds the 4 MiB byte bound");
+  }
+  exactKeys(value.completion, ["schema", "status", "reportRoot", "eventCount"], [], "terminalCapture.completion");
+  invariant(
+    value.completion.schema === "kungfu.agent-work-lab.tui-autoplay/v1"
+      && value.completion.status === "qualified"
+      && digestPattern.test(value.completion.reportRoot),
+    "terminal capture completion sentinel is not a qualified Agent Work Lab autoplay",
+  );
+  integer(value.completion.eventCount, 1, 100_000, "terminalCapture.completion.eventCount");
+  invariant(value.exitCode === 0, "terminal capture exitCode must be zero");
+  exactKeys(value.authority, ["classification", "grants", "nonAuthorities"], [], "terminalCapture.authority");
+  invariant(value.authority.classification === "volatile-terminal-observation", "terminal capture authority classification must remain observation-only");
+  invariant(Array.isArray(value.authority.grants) && value.authority.grants.length === 0, "terminal capture must not grant authority");
+  invariant(
+    JSON.stringify(value.authority.nonAuthorities) === JSON.stringify(TERMINAL_CAPTURE_NON_AUTHORITIES),
+    "terminal capture must declare every identity and metadata non-authority",
+  );
+  return value;
+}
+
+export function validateRenditionSet(output, helpers) {
+  const { decodeUtf8, exactKeys, invariant, maxBytes, readJson, readRegular, sha256, validateProjection, validateScene } = helpers;
+  const manifestPath = path.join(output, "rendition-set.json");
+  if (!fs.existsSync(manifestPath)) return null;
+  const value = readJson(manifestPath, "rendition set");
+  exactKeys(value, ["schema", "renditions", "authority"], [], "renditionSet");
+  invariant(value.schema === "kungfu.auditable-demo.rendition-set/v1", "unsupported rendition set schema");
+  exactKeys(value.authority, ["classification", "grants", "nonAuthorities"], [], "renditionSet.authority");
+  invariant(
+    value.authority.classification === "capture-routing-metadata"
+      && Array.isArray(value.authority.grants)
+      && value.authority.grants.length === 0
+      && JSON.stringify(value.authority.nonAuthorities) === JSON.stringify(RENDITION_SET_NON_AUTHORITIES),
+    "rendition set authority boundary is invalid",
+  );
+  invariant(Array.isArray(value.renditions) && value.renditions.length === 2, "rendition set must contain exactly two captures");
+  const expected = [
+    {
+      id: "1080p", role: "primary", transcript: "complete-transcript.txt",
+      projection: "public-projection.json", scene: "scene.json", terminalCapture: "terminal-capture.json",
+      width: 1920, height: 1080,
+    },
+    {
+      id: "720p", role: "responsive", transcript: "complete-transcript-720p.txt",
+      projection: "public-projection-720p.json", scene: "scene-720p.json", terminalCapture: "terminal-capture-720p.json",
+      width: 1280, height: 720,
+    },
+  ];
+  const normalized = value.renditions.map((entry, index) => {
+    const label = `renditionSet.renditions[${index}]`;
+    exactKeys(entry, ["id", "role", "transcript", "projection", "scene", "terminalCapture", "captureRoot"], [], label);
+    const declaration = expected[index];
+    for (const key of ["id", "role", "transcript", "projection", "scene", "terminalCapture"]) {
+      invariant(entry[key] === declaration[key], `${label}.${key} is not the exact native rendition contract`);
+    }
+    const transcriptBytes = readRegular(path.join(output, entry.transcript), `${label} transcript`, 4 * 1024 * 1024);
+    const transcript = decodeUtf8(transcriptBytes, `${label} transcript`).replace(/\r\n/g, "\n");
+    invariant(transcript.trim().length > 0, `${label} transcript must not be empty`);
+    const lines = transcript.endsWith("\n") ? transcript.slice(0, -1).split("\n") : transcript.split("\n");
+    const scene = validateScene(readJson(path.join(output, entry.scene), `${label} scene`));
+    invariant(scene.width === declaration.width && scene.height === declaration.height, `${label} scene dimensions are not native`);
+    const projection = validateProjection(readJson(path.join(output, entry.projection), `${label} projection`), scene, lines.length);
+    const captureBytes = readRegular(path.join(output, entry.terminalCapture), `${label} terminal capture`, maxBytes);
+    const capture = validateTerminalCapture(JSON.parse(decodeUtf8(captureBytes, `${label} terminal capture`)), scene, helpers);
+    invariant(entry.captureRoot === sha256(captureBytes), `${label}.captureRoot mismatch`);
+    return { ...entry, transcript, lines, scene, projection, capture };
+  });
+  invariant(normalized[0].captureRoot !== normalized[1].captureRoot, "native rendition capture roots must be distinct");
+  invariant(
+    JSON.stringify(normalized[0].capture.dimensions) !== JSON.stringify(normalized[1].capture.dimensions),
+    "native rendition PTY dimensions must be distinct",
+  );
+  invariant(
+    normalized[0].projection.evidenceClass === normalized[1].projection.evidenceClass
+      && normalized[0].projection.claimBoundary === normalized[1].projection.claimBoundary,
+    "native rendition evidence boundaries must match",
+  );
+  return { schema: value.schema, renditions: normalized, authority: value.authority };
+}

package/scripts/auditable-demo.mjs

@@ -7,6 +7,10 @@ import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
+import {
+  validateRenditionSet,
+  validateTerminalCapture,
+} from "./auditable-demo-renditions.mjs";
 
 const UTF8 = new TextDecoder("utf-8", { fatal: true });
 const IMAGE_PATTERN = /^[a-z0-9][a-z0-9./_-]*@sha256:[0-9a-f]{64}$/;
@@ -22,19 +26,16 @@ const REQUIRED_ADAPTER_FILES = [
   "public-projection.json",
   "scene.json",
 ];
-const OPTIONAL_ADAPTER_FILES = ["terminal-capture.json"];
+const OPTIONAL_ADAPTER_FILES = [
+  "terminal-capture.json",
+  "complete-transcript-720p.txt",
+  "public-projection-720p.json",
+  "scene-720p.json",
+  "terminal-capture-720p.json",
+  "rendition-set.json",
+];
 const MAX_TERMINAL_CAPTURE_BYTES = 4 * 1024 * 1024;
 const MAX_TERMINAL_CAPTURE_EVENTS = 10_000;
-const TERMINAL_CAPTURE_NON_AUTHORITIES = [
-  "first-party-identity",
-  "system-identity",
-  "kfd-compliance",
-  "product-system-metadata",
-  "package-metadata",
-  "registry-history",
-  "scan-output",
-  "standalone-generation",
-];
 
 function invariant(condition, message) {
   if (!condition) throw new Error(message);
@@ -249,80 +250,11 @@ function validateProjection(value, scene, transcriptLineCount) {
   };
 }
 
-function validateTerminalCapture(value, scene) {
-  exactKeys(
-    value,
-    [
-      "schema",
-      "command",
-      "dimensions",
-      "durationMs",
-      "encoding",
-      "events",
-      "completion",
-      "exitCode",
-      "authority",
-    ],
-    [],
-    "terminalCapture",
-  );
-  invariant(value.schema === "kungfu.terminal-capture/v1", "unsupported terminal capture schema");
-  text(value.command, 1, 160, "terminalCapture.command");
-  exactKeys(value.dimensions, ["columns", "rows"], [], "terminalCapture.dimensions");
-  integer(value.dimensions.columns, 80, 200, "terminalCapture.dimensions.columns");
-  integer(value.dimensions.rows, 24, 80, "terminalCapture.dimensions.rows");
-  const durationMs = integer(value.durationMs, 500, 60000, "terminalCapture.durationMs");
-  invariant(
-    durationMs <= scene.durationMs && scene.durationMs - durationMs <= 2000,
-    "terminal capture duration must end within two seconds of the scene",
-  );
-  invariant(value.encoding === "base64", "terminalCapture.encoding must be base64");
-  invariant(
-    Array.isArray(value.events)
-      && value.events.length > 0
-      && value.events.length <= MAX_TERMINAL_CAPTURE_EVENTS,
-    `terminalCapture.events must contain 1 through ${MAX_TERMINAL_CAPTURE_EVENTS} events`,
-  );
-  let previousAtMs = -1;
-  let totalBytes = 0;
-  for (const [index, event] of value.events.entries()) {
-    exactKeys(event, ["atMs", "data"], [], `terminalCapture.events[${index}]`);
-    const atMs = integer(event.atMs, 0, durationMs - 1, `terminalCapture.events[${index}].atMs`);
-    invariant(atMs >= previousAtMs, "terminal capture event timestamps must be monotonic");
-    invariant(index > 0 || atMs === 0, "the first terminal capture event must start at zero");
-    previousAtMs = atMs;
-    totalBytes += decodeBase64(event.data, `terminalCapture.events[${index}].data`).length;
-    invariant(totalBytes <= MAX_TERMINAL_CAPTURE_BYTES, "terminal capture exceeds the 4 MiB byte bound");
-  }
-  exactKeys(
-    value.completion,
-    ["schema", "status", "reportRoot", "eventCount"],
-    [],
-    "terminalCapture.completion",
-  );
-  invariant(
-    value.completion.schema === "kungfu.agent-work-lab.tui-autoplay/v1"
-      && value.completion.status === "qualified"
-      && DIGEST_PATTERN.test(value.completion.reportRoot),
-    "terminal capture completion sentinel is not a qualified Agent Work Lab autoplay",
-  );
-  integer(value.completion.eventCount, 1, 100_000, "terminalCapture.completion.eventCount");
-  invariant(value.exitCode === 0, "terminal capture exitCode must be zero");
-  exactKeys(value.authority, ["classification", "grants", "nonAuthorities"], [], "terminalCapture.authority");
-  invariant(
-    value.authority.classification === "volatile-terminal-observation",
-    "terminal capture authority classification must remain observation-only",
-  );
-  invariant(
-    Array.isArray(value.authority.grants) && value.authority.grants.length === 0,
-    "terminal capture must not grant authority",
-  );
-  invariant(
-    JSON.stringify(value.authority.nonAuthorities) === JSON.stringify(TERMINAL_CAPTURE_NON_AUTHORITIES),
-    "terminal capture must declare every identity and metadata non-authority",
-  );
-  return value;
-}
+const RENDITION_VALIDATION_HELPERS = {
+  decodeBase64, decodeUtf8, digestPattern: DIGEST_PATTERN, exactKeys, integer, invariant,
+  maxBytes: MAX_TERMINAL_CAPTURE_BYTES, maxEvents: MAX_TERMINAL_CAPTURE_EVENTS,
+  readJson, readRegular, sha256, text, validateProjection, validateScene,
+};
 
 function validateSourceCoordinate(value) {
   exactKeys(
@@ -379,8 +311,17 @@ function validateAdapterOutput(output, strict = true) {
   );
   const terminalCapturePath = path.join(output, "terminal-capture.json");
   const terminalCapture = fs.existsSync(terminalCapturePath)
-    ? validateTerminalCapture(readJson(terminalCapturePath, "terminal capture"), scene)
+    ? validateTerminalCapture(
+      readJson(terminalCapturePath, "terminal capture"),
+      scene,
+      RENDITION_VALIDATION_HELPERS,
+    )
     : null;
+  const renditionSet = validateRenditionSet(output, RENDITION_VALIDATION_HELPERS);
+  invariant(
+    !renditionSet || terminalCapture,
+    "rendition set requires the primary terminal capture",
+  );
   if (strict) {
     const allowed = new Set([...REQUIRED_ADAPTER_FILES, ...OPTIONAL_ADAPTER_FILES]);
     for (const member of listFiles(output)) invariant(allowed.has(member), `undeclared adapter output: ${member}`);
@@ -391,6 +332,7 @@ function validateAdapterOutput(output, strict = true) {
     scene,
     projection,
     terminalCapture,
+    renditionSet,
   };
 }
 
@@ -1047,6 +989,21 @@ function verifyRendererOutput(renderOutput, expectedImage, expectedInputs, optio
     const observed = manifest.inputs?.[key]?.root;
     invariant(observed === sha256(readRegular(filePath, `${key} input`)), `renderer ${key} input root mismatch`);
   }
+  if (expectedInputs.renditionSet) {
+    invariant(
+      manifest.derivation?.policy === "independent-native-frame-sets/v1",
+      "renderer did not use independent native frame sets",
+    );
+    invariant(
+      Array.isArray(manifest.inputs?.renditions)
+        && manifest.inputs.renditions.length === 2
+        && manifest.inputs.renditions[0]?.role === "primary"
+        && manifest.inputs.renditions[1]?.role === "responsive"
+        && manifest.inputs.renditions[0]?.terminalCapture?.root
+          !== manifest.inputs.renditions[1]?.terminalCapture?.root,
+      "renderer native rendition inputs are not independently bound",
+    );
+  }
   const probe = readJson(path.join(renderOutput, "media-probe.json"), "media probe");
   invariant(probe.schema === "build-images.demo-media-probe/v1" && probe.passed === true, "renderer media probe failed");
   const qualification = qualifyRendererOutput(
@@ -1099,11 +1056,10 @@ function finalizeGate(values) {
   fs.writeFileSync(path.join(output, "complete-transcript.txt"), normalized.transcript);
   writeJson(path.join(output, "scene.json"), normalized.scene);
   writeJson(path.join(output, "public-projection.json"), normalized.projection);
-  if (normalized.terminalCapture) {
-    copyFile(
-      path.join(adapterOutput, "terminal-capture.json"),
-      path.join(output, "terminal-capture.json"),
-    );
+  for (const name of OPTIONAL_ADAPTER_FILES) {
+    if (fs.existsSync(path.join(adapterOutput, name))) {
+      copyFile(path.join(adapterOutput, name), path.join(output, name));
+    }
   }
   copyFile(sourceCoordinatePath, path.join(output, "source-artifact.json"));
   copyFile(path.join(diagnostics, "adapter.json"), path.join(output, "adapter.json"));
@@ -1148,6 +1104,22 @@ function finalizeGate(values) {
           },
         }
         : {}),
+      ...(normalized.renditionSet
+        ? {
+          renditionSet: {
+            schema: normalized.renditionSet.schema,
+            root: sha256(readRegular(path.join(output, "rendition-set.json"), "rendition set")),
+            renditions: normalized.renditionSet.renditions.map((rendition) => ({
+              id: rendition.id,
+              role: rendition.role,
+              captureRoot: rendition.captureRoot,
+              sceneRoot: sha256(readRegular(path.join(output, rendition.scene), `${rendition.id} scene`)),
+              transcriptRoot: sha256(readRegular(path.join(output, rendition.transcript), `${rendition.id} transcript`)),
+              projectionRoot: sha256(readRegular(path.join(output, rendition.projection), `${rendition.id} projection`)),
+            })),
+          },
+        }
+        : {}),
       evidenceClass: normalized.projection.evidenceClass,
       claimBoundary: normalized.projection.claimBoundary,
     },
@@ -1198,6 +1170,27 @@ function verifyGate(values) {
       "gate terminal capture root mismatch",
     );
   }
+  const qualifiedRenditionSet = receipt.qualifiedInputs?.renditionSet;
+  invariant(
+    Boolean(qualifiedRenditionSet) === Boolean(normalized.renditionSet),
+    "gate rendition set presence drifted",
+  );
+  if (normalized.renditionSet) {
+    invariant(
+      qualifiedRenditionSet.schema === normalized.renditionSet.schema
+        && qualifiedRenditionSet.root === sha256(readRegular(path.join(bundle, "rendition-set.json"), "rendition set"))
+        && JSON.stringify(qualifiedRenditionSet.renditions)
+          === JSON.stringify(normalized.renditionSet.renditions.map((rendition) => ({
+            id: rendition.id,
+            role: rendition.role,
+            captureRoot: rendition.captureRoot,
+            sceneRoot: sha256(readRegular(path.join(bundle, rendition.scene), `${rendition.id} scene`)),
+            transcriptRoot: sha256(readRegular(path.join(bundle, rendition.transcript), `${rendition.id} transcript`)),
+            projectionRoot: sha256(readRegular(path.join(bundle, rendition.projection), `${rendition.id} projection`)),
+          }))),
+      "gate native rendition roots mismatch",
+    );
+  }
   invariant(receipt.qualifiedInputs.evidenceClass === normalized.projection.evidenceClass, "gate evidence class drifted");
 }
 
@@ -1228,6 +1221,7 @@ function finalizeMedia(values) {
     "--media-profile": mediaProfile,
   });
   const terminalCapturePath = path.join(gateBundle, "terminal-capture.json");
+  const renditionSetPath = path.join(gateBundle, "rendition-set.json");
   const verifiedRenderer = verifyRendererOutput(renderOutput, rendererImage, {
     scene: path.join(gateBundle, "scene.json"),
     transcript: path.join(gateBundle, "complete-transcript.txt"),
@@ -1235,6 +1229,9 @@ function finalizeMedia(values) {
     ...(fs.existsSync(terminalCapturePath)
       ? { terminalCapture: terminalCapturePath }
       : {}),
+    ...(fs.existsSync(renditionSetPath)
+      ? { renditionSet: renditionSetPath }
+      : {}),
   }, {
     mediaProfile,
     inspectMedia: mediaInspection?.inspectMedia,