@tendrilapp/cli 0.1.50 → 0.1.51

package/dist/tendril.js

@@ -2584,8 +2584,8 @@ var init_src = __esm({
 function variableNameToPath(name) {
   return name.split("/").map(canonicalCssIdentPart).filter((part) => part.length > 0);
 }
-function tokenPathToCssVar(path60) {
-  return `--${path60.join("-")}`;
+function tokenPathToCssVar(path62) {
+  return `--${path62.join("-")}`;
 }
 function toDtcgToken(variable, defaultMode) {
   const modes = Object.keys(variable.valuesByMode);
@@ -2629,11 +2629,11 @@ function toDtcgToken(variable, defaultMode) {
 }
 function mapVariablesToDtcg(variables, defaultMode = "light") {
   const entries = variables.map((variable) => {
-    const path60 = variableNameToPath(variable.name);
-    if (path60.length === 0) {
+    const path62 = variableNameToPath(variable.name);
+    if (path62.length === 0) {
       throw new DtcgMappingError("empty-name", `Figma variable ${variable.id} has an empty name`);
     }
-    return { variable, path: path60 };
+    return { variable, path: path62 };
   });
   const groupPrefixes = /* @__PURE__ */ new Set();
   for (const e of entries) {
@@ -2654,21 +2654,21 @@ function mapVariablesToDtcg(variables, defaultMode = "light") {
   }
   const tokens = {};
   const flat = [];
-  for (const { variable, path: path60 } of entries) {
+  for (const { variable, path: path62 } of entries) {
     const token = toDtcgToken(variable, defaultMode);
     let group = tokens;
-    for (const segment of path60.slice(0, -1)) {
+    for (const segment of path62.slice(0, -1)) {
       const existing = group[segment];
       group = existing ?? (group[segment] = {});
     }
-    const leaf = path60[path60.length - 1];
+    const leaf = path62[path62.length - 1];
     if (group[leaf] !== void 0) {
-      throw new DtcgMappingError("duplicate-path", `Duplicate token path "${path60.join(".")}" (variable ${variable.id})`);
+      throw new DtcgMappingError("duplicate-path", `Duplicate token path "${path62.join(".")}" (variable ${variable.id})`);
     }
     group[leaf] = token;
     flat.push({
-      path: path60.join("."),
-      cssVar: tokenPathToCssVar(path60),
+      path: path62.join("."),
+      cssVar: tokenPathToCssVar(path62),
       type: token.$type,
       value: token.$value
     });
@@ -2857,9 +2857,9 @@ function boundId(value) {
   return isObject(value) && typeof value["boundVariableId"] === "string" ? value["boundVariableId"] : void 0;
 }
 function resolveBinding(ctx, id) {
-  const path60 = ctx.pathById.get(id);
-  if (path60 === void 0) ctx.unresolved.add(id);
-  return path60;
+  const path62 = ctx.pathById.get(id);
+  if (path62 === void 0) ctx.unresolved.add(id);
+  return path62;
 }
 function parseVariantProps(name) {
   if (!name.includes("=")) return void 0;
@@ -2894,8 +2894,8 @@ function walk(ctx, raw) {
       if (!isObject(paint) || paint["visible"] === false) continue;
       const id = boundId(paint);
       if (id !== void 0) {
-        const path60 = resolveBinding(ctx, id);
-        if (path60 !== void 0) tokens.add(path60);
+        const path62 = resolveBinding(ctx, id);
+        if (path62 !== void 0) tokens.add(path62);
       } else if (typeof paint["color"] === "string") {
         ctx.hardcoded.push({ node: name, property, value: paint["color"] });
       }
@@ -2903,8 +2903,8 @@ function walk(ctx, raw) {
   }
   const radiusId = boundId(raw["cornerRadius"]);
   if (radiusId !== void 0) {
-    const path60 = resolveBinding(ctx, radiusId);
-    if (path60 !== void 0) tokens.add(path60);
+    const path62 = resolveBinding(ctx, radiusId);
+    if (path62 !== void 0) tokens.add(path62);
   } else if (typeof raw["cornerRadius"] === "number" && raw["cornerRadius"] !== 0) {
     ctx.hardcoded.push({ node: name, property: "border-radius", value: `${raw["cornerRadius"]}px` });
   }
@@ -2914,10 +2914,10 @@ function walk(ctx, raw) {
     layout = { mode: layoutMode === "HORIZONTAL" ? "flex-row" : "flex-column" };
     const gapId = boundId(raw["itemSpacing"]);
     if (gapId !== void 0) {
-      const path60 = resolveBinding(ctx, gapId);
-      if (path60 !== void 0) {
-        layout.gap = path60;
-        tokens.add(path60);
+      const path62 = resolveBinding(ctx, gapId);
+      if (path62 !== void 0) {
+        layout.gap = path62;
+        tokens.add(path62);
       }
     } else if (typeof raw["itemSpacing"] === "number" && raw["itemSpacing"] !== 0) {
       ctx.hardcoded.push({ node: name, property: "gap", value: `${raw["itemSpacing"]}px` });
@@ -2926,10 +2926,10 @@ function walk(ctx, raw) {
     for (const field of PADDING_FIELDS) {
       const id = boundId(raw[field]);
       if (id !== void 0) {
-        const path60 = resolveBinding(ctx, id);
-        if (path60 !== void 0) {
-          paddingPaths.push(path60);
-          tokens.add(path60);
+        const path62 = resolveBinding(ctx, id);
+        if (path62 !== void 0) {
+          paddingPaths.push(path62);
+          tokens.add(path62);
         }
       } else if (typeof raw[field] === "number" && raw[field] !== 0) {
         ctx.hardcoded.push({ node: name, property: field, value: `${raw[field]}px` });
@@ -5179,10 +5179,10 @@ async function resolveFonts(family, weights, cacheDir = DEFAULT_FONT_CACHE) {
         continue;
       }
       const bytes = new Uint8Array(await fileRes.arrayBuffer());
-      const sha256 = createHash4("sha256").update(bytes).digest("hex");
+      const sha2562 = createHash4("sha256").update(bytes).digest("hex");
       const file = path14.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${weight}.woff2`);
       writeFileSync3(file, bytes);
-      resolved.push({ family, weight, source: url, sha256, file, license: meta.license, ...meta.family !== null ? { servedFamily: meta.family } : {} });
+      resolved.push({ family, weight, source: url, sha256: sha2562, file, license: meta.license, ...meta.family !== null ? { servedFamily: meta.family } : {} });
     } catch (err) {
       failures.push({ family, weight, reason: `download failed: ${err instanceof Error ? err.message : String(err)}` });
     }
@@ -5220,10 +5220,10 @@ ${shown}`
     storedExt = ".ttf";
   }
   mkdirSync2(cacheDir, { recursive: true });
-  const sha256 = createHash4("sha256").update(bytes).digest("hex");
+  const sha2562 = createHash4("sha256").update(bytes).digest("hex");
   const file = path14.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${weight}${storedExt}`);
   writeFileSync3(file, bytes);
-  const face = { family, weight, source: `${provenance}:${path14.basename(src)}`, sha256, file, license: "unknown" };
+  const face = { family, weight, source: `${provenance}:${path14.basename(src)}`, sha256: sha2562, file, license: "unknown" };
   const mPath = path14.join(cacheDir, "manifest.json");
   const prior = existsSync10(mPath) ? JSON.parse(readFileSync7(mPath, "utf8")) : [];
   const merged = [...prior.filter((p) => !(p.family === family && p.weight === weight)), { ...face, file: path14.basename(file) }];
@@ -6719,7 +6719,7 @@ function cssProvenanceComment(input) {
   const unrecorded = input.latticeConfigs === null ? "; coverage denominator unknown" : `; ${Math.max(0, input.latticeConfigs - input.scored)} lattice configs unverified`;
   return `/* tendril bundle v${BUNDLE_VERSION} \u2014 ${input.pass}/${input.scored} recorded configs \u2265 pass bar, ${input.certified} certified${unrecorded}. Non-authoritative claim AT STAMP TIME \u2014 any edit invalidates it; recompute with \`tendril verify\`. */`;
 }
-function hashRecordingSet(relPaths, readFile, sha256) {
+function hashRecordingSet(relPaths, readFile, sha2562) {
   const sorted = [...relPaths].sort();
   const chunks = [];
   const encoder = new TextEncoder();
@@ -6728,7 +6728,7 @@ function hashRecordingSet(relPaths, readFile, sha256) {
 `));
     chunks.push(readFile(p));
   }
-  return sha256(chunks);
+  return sha2562(chunks);
 }
 var BUNDLE_VERSION, ConfigStatusSchema, PinnedPropSchema, PropAdapterSchema, RequiredFontSchema, ConfigClaimSchema, BehaviorClaimSchema, BundleProvenanceSchema, BundleComponentJsonSchema, MAX_BUNDLE_MANIFEST_BYTES, MAX_BUNDLE_SOURCE_BYTES;
 var init_bundle = __esm({
@@ -6857,43 +6857,43 @@ function classifyBundleSurface(files, opts) {
   const excluded = [];
   const unknown = [];
   for (const raw of files) {
-    const path60 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
-    const inEvidence = path60.startsWith(`${EVIDENCE_DIR}/`);
-    if (path60.startsWith("fonts/")) {
-      const fname = path60.slice("fonts/".length);
+    const path62 = raw.replace(/\\/g, "/").replace(/^\.\//, "");
+    const inEvidence = path62.startsWith(`${EVIDENCE_DIR}/`);
+    if (path62.startsWith("fonts/")) {
+      const fname = path62.slice("fonts/".length);
       if (!fname.includes("/") && (/\.(woff2?|ttf|otf)$/i.test(fname) || /^(NOTICE|LICENSE|LICENCE)[^/]*\.txt$/i.test(fname))) {
-        excluded.push({ path: path60, reason: "font payload \u2014 not published (fonts policy pending); faces are sha-pinned in component.json requiredFonts" });
+        excluded.push({ path: path62, reason: "font payload \u2014 not published (fonts policy pending); faces are sha-pinned in component.json requiredFonts" });
         continue;
       }
-      unknown.push(path60);
+      unknown.push(path62);
       continue;
     }
-    const name = inEvidence ? path60.slice(EVIDENCE_DIR.length + 1) : path60;
+    const name = inEvidence ? path62.slice(EVIDENCE_DIR.length + 1) : path62;
     if (name.includes("/")) {
-      unknown.push(path60);
+      unknown.push(path62);
       continue;
     }
     if (inEvidence) {
-      if (name === "verify-report.json") published.push({ path: path60, role: "verify-report" });
-      else if (name === "diff-legend.txt") published.push({ path: path60, role: "diff-legend" });
-      else if (name === "inspect.html") published.push({ path: path60, role: "inspect-sheet" });
-      else if (/-mount-failure\.png$/.test(name)) excluded.push({ path: path60, reason: "harness failure diagnostic (regenerated every verify run, never published)" });
+      if (name === "verify-report.json") published.push({ path: path62, role: "verify-report" });
+      else if (name === "diff-legend.txt") published.push({ path: path62, role: "diff-legend" });
+      else if (name === "inspect.html") published.push({ path: path62, role: "inspect-sheet" });
+      else if (/-mount-failure\.png$/.test(name)) excluded.push({ path: path62, reason: "harness failure diagnostic (regenerated every verify run, never published)" });
       else {
         const hit = EVIDENCE_PATTERNS.find((p) => p.re.test(name));
-        if (hit !== void 0) published.push({ path: path60, role: hit.role });
-        else unknown.push(path60);
+        if (hit !== void 0) published.push({ path: path62, role: hit.role });
+        else unknown.push(path62);
       }
       continue;
     }
-    if (name === opts.entry) published.push({ path: path60, role: "entry" });
-    else if (name === "styles.css") published.push({ path: path60, role: "styles" });
-    else if (name === "tokens.css") published.push({ path: path60, role: "tokens" });
-    else if (name === "fonts.css") published.push({ path: path60, role: "fonts" });
-    else if (name === "component.json") published.push({ path: path60, role: "manifest" });
+    if (name === opts.entry) published.push({ path: path62, role: "entry" });
+    else if (name === "styles.css") published.push({ path: path62, role: "styles" });
+    else if (name === "tokens.css") published.push({ path: path62, role: "tokens" });
+    else if (name === "fonts.css") published.push({ path: path62, role: "fonts" });
+    else if (name === "component.json") published.push({ path: path62, role: "manifest" });
     else {
       const skip = EXCLUDED.find((e) => e.test(name));
-      if (skip !== void 0) excluded.push({ path: path60, reason: skip.reason });
-      else unknown.push(path60);
+      if (skip !== void 0) excluded.push({ path: path62, reason: skip.reason });
+      else unknown.push(path62);
     }
   }
   const roles = new Set(published.map((p) => p.role));
@@ -6903,8 +6903,8 @@ function missingInspectCrops(sheetText, publishedPaths) {
   const held = new Set(publishedPaths);
   const missing = /* @__PURE__ */ new Set();
   for (const [, name] of sheetText.matchAll(/src="\.\/([^"]+)"/g)) {
-    const path60 = `${EVIDENCE_DIR}/${name}`;
-    if (!held.has(path60)) missing.add(path60);
+    const path62 = `${EVIDENCE_DIR}/${name}`;
+    if (!held.has(path62)) missing.add(path62);
   }
   return [...missing].sort();
 }
@@ -7012,10 +7012,10 @@ function readScoredFiles(report) {
   const entries = Object.entries(value);
   if (entries.length === 0) return void 0;
   const out = {};
-  for (const [path60, digest] of entries) {
-    if (path60 === "" || path60.startsWith("/") || path60.includes("..")) return void 0;
+  for (const [path62, digest] of entries) {
+    if (path62 === "" || path62.startsWith("/") || path62.includes("..")) return void 0;
     if (!isSetHash(digest)) return void 0;
-    out[path60] = digest;
+    out[path62] = digest;
   }
   return out;
 }
@@ -7023,11 +7023,11 @@ function compareScoredFiles(recorded, actual) {
   const missing = [];
   const unscored = [];
   const changed = [];
-  for (const [path60, digest] of Object.entries(recorded)) {
-    if (!(path60 in actual)) missing.push(path60);
-    else if (actual[path60] !== digest) changed.push(path60);
+  for (const [path62, digest] of Object.entries(recorded)) {
+    if (!(path62 in actual)) missing.push(path62);
+    else if (actual[path62] !== digest) changed.push(path62);
   }
-  for (const path60 of Object.keys(actual)) if (!(path60 in recorded)) unscored.push(path60);
+  for (const path62 of Object.keys(actual)) if (!(path62 in recorded)) unscored.push(path62);
   return { missing: missing.sort(), unscored: unscored.sort(), changed: changed.sort() };
 }
 function scoredRecordingSetHash(report) {
@@ -7068,8 +7068,318 @@ var init_motion_css = __esm({
   }
 });
 
-// packages/metadata/src/profile.ts
+// packages/metadata/src/recording-archive.ts
 import { z as z11 } from "zod";
+function bytesToBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += B64_ALPHABET[a >> 2] + B64_ALPHABET[(a & 3) << 4 | b >> 4];
+    out += i + 1 < bytes.length ? B64_ALPHABET[(b & 15) << 2 | c >> 6] : "=";
+    out += i + 2 < bytes.length ? B64_ALPHABET[c & 63] : "=";
+  }
+  return out;
+}
+function base64ToBytes(text) {
+  if (text.length % 4 !== 0) return void 0;
+  const padIdx = text.indexOf("=");
+  const pad = padIdx === -1 ? 0 : text.length - padIdx;
+  if (pad > 2 || padIdx !== -1 && !/^={1,2}$/.test(text.slice(padIdx))) return void 0;
+  const body = padIdx === -1 ? text : text.slice(0, padIdx);
+  const out = new Uint8Array(text.length / 4 * 3 - pad);
+  let o = 0;
+  let buffer = 0;
+  let bits = 0;
+  for (const ch of body) {
+    const v = B64_ALPHABET.indexOf(ch);
+    if (v === -1) return void 0;
+    buffer = buffer << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = buffer >> bits & 255;
+    }
+  }
+  if (bits > 0 && (buffer & (1 << bits) - 1) !== 0) return void 0;
+  return out;
+}
+function readSetShape(manifestBytes) {
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(manifestBytes));
+  } catch {
+    return { ok: false, refusal: "the carried recording-set.json is not readable JSON" };
+  }
+  const m = parsed;
+  if (typeof m.component !== "string" || m.component === "") return { ok: false, refusal: "the carried recording-set.json names no component" };
+  if (!Array.isArray(m.reps) || m.reps.length === 0) return { ok: false, refusal: "the carried recording-set.json declares no reps" };
+  const reps = [];
+  for (const rep of m.reps) {
+    const slug = rep.slug;
+    if (typeof slug !== "string" || !safeSegment(slug)) {
+      return { ok: false, refusal: `the carried recording-set.json declares a rep slug that is not a safe directory name (${JSON.stringify(slug).slice(0, 80)})` };
+    }
+    if (reps.includes(slug)) return { ok: false, refusal: `the carried recording-set.json declares the rep ${slug} twice` };
+    reps.push(slug);
+  }
+  return {
+    ok: true,
+    shape: {
+      component: m.component,
+      ...typeof m.figmaFile === "string" ? { figmaFile: m.figmaFile } : {},
+      channeled: m.channel !== void 0,
+      reps
+    }
+  };
+}
+function recordingSetEnumeration(input, fs4) {
+  const relPaths = [];
+  const setLevel = ["recording-set.json", "completeness-manifest.json", "get_variable_defs.json", "get_metadata.json", ...input.channeled ? ["get_motion_context.json"] : []];
+  for (const name of setLevel) {
+    if (fs4.exists(name)) relPaths.push(name);
+  }
+  const perRep = [
+    "get_design_context.json",
+    "get_metadata.json",
+    "get_screenshot.json",
+    "get_variable_defs.json",
+    ...input.channeled ? ["get_metadata_interior.json", "rest_nodes.json", "rest_metadata.json", "rest_screenshot.json"] : []
+  ];
+  for (const rep of input.reps) {
+    for (const f of perRep) {
+      if (fs4.exists(`${rep}/${f}`)) relPaths.push(`${rep}/${f}`);
+    }
+    for (const asset of fs4.listRep(rep).filter((f) => f.startsWith("asset-"))) {
+      relPaths.push(`${rep}/${asset}`);
+    }
+  }
+  return relPaths;
+}
+function archiveMemberAllowed(shape, memberPath) {
+  const setLevel = /* @__PURE__ */ new Set([
+    "recording-set.json",
+    "completeness-manifest.json",
+    "get_variable_defs.json",
+    "get_metadata.json",
+    "get_motion_context.json",
+    ...SET_LEVEL_EXTRAS
+  ]);
+  if (setLevel.has(memberPath)) return true;
+  const slash = memberPath.indexOf("/");
+  if (slash === -1) return false;
+  const rep = memberPath.slice(0, slash);
+  const name = memberPath.slice(slash + 1);
+  if (!shape.reps.includes(rep)) return false;
+  const perRep = /* @__PURE__ */ new Set([
+    "get_design_context.json",
+    "get_metadata.json",
+    "get_screenshot.json",
+    "get_variable_defs.json",
+    "get_metadata_interior.json",
+    "rest_nodes.json",
+    "rest_metadata.json",
+    "rest_screenshot.json",
+    ...PER_REP_EXTRAS
+  ]);
+  if (perRep.has(name)) return true;
+  return name.startsWith("asset-") && safeSegment(name);
+}
+function carriedExtrasHash(members, enumeration, sha2562) {
+  const hashed = new Set(enumeration);
+  const extras = [...members.keys()].filter((p) => !hashed.has(p)).sort();
+  return hashRecordingSet(extras, (p) => members.get(p), sha2562);
+}
+function validateRecordingArchive(envelopeText2, opts) {
+  let parsed;
+  try {
+    parsed = JSON.parse(envelopeText2);
+  } catch {
+    return { ok: false, refusal: "the recording archive is not readable JSON" };
+  }
+  const env = RecordingArchiveEnvelopeSchema.safeParse(parsed);
+  if (!env.success) {
+    return { ok: false, refusal: `the recording archive is not a v${String(RECORDING_ARCHIVE_VERSION)} envelope (${env.error.issues[0]?.message ?? "invalid"})` };
+  }
+  const members = /* @__PURE__ */ new Map();
+  const folded = /* @__PURE__ */ new Set();
+  let previous = "";
+  for (const f of env.data.files) {
+    if (f.path <= previous) {
+      return { ok: false, refusal: `the archive's members are not in canonical order (${JSON.stringify(f.path)} after ${JSON.stringify(previous)})` };
+    }
+    previous = f.path;
+    const lower = f.path.toLowerCase();
+    if (folded.has(lower)) return { ok: false, refusal: `the archive carries two members that collide on a case-insensitive filesystem (${f.path})` };
+    folded.add(lower);
+    const bytes = base64ToBytes(f.bytes);
+    if (bytes === void 0) return { ok: false, refusal: `the archive member ${f.path} is not canonical base64` };
+    if (bytes.length > MAX_MEMBER_BYTES) return { ok: false, refusal: `the archive member ${f.path} exceeds ${String(MAX_MEMBER_BYTES)} bytes` };
+    members.set(f.path, bytes);
+  }
+  const manifestBytes = members.get("recording-set.json");
+  if (manifestBytes === void 0) return { ok: false, refusal: "the archive carries no recording-set.json \u2014 there is no set to reconstruct" };
+  const read = readSetShape(manifestBytes);
+  if (!read.ok) return read;
+  const shape = read.shape;
+  for (const memberPath of members.keys()) {
+    if (!archiveMemberAllowed(shape, memberPath)) {
+      return { ok: false, refusal: `the archive carries a file outside the recording-set vocabulary (${memberPath}) \u2014 refused, never silently unpacked` };
+    }
+  }
+  const enumeration = recordingSetEnumeration(
+    { channeled: shape.channeled, reps: shape.reps },
+    {
+      exists: (p) => members.has(p),
+      listRep: (rep) => [...members.keys()].filter((p) => p.startsWith(`${rep}/`)).map((p) => p.slice(rep.length + 1))
+    }
+  );
+  const enumerated = new Set(enumeration);
+  for (const memberPath of members.keys()) {
+    if (enumerated.has(memberPath)) continue;
+    const isExtra = SET_LEVEL_EXTRAS.includes(memberPath) || PER_REP_EXTRAS.some((name) => shape.reps.some((rep) => memberPath === `${rep}/${name}`));
+    if (!isExtra) return { ok: false, refusal: `the archive member ${memberPath} is neither hashed nor a named extra for this set's channel` };
+  }
+  const utf8 = new TextDecoder("utf-8", { fatal: true });
+  for (const [memberPath, bytes] of members) {
+    if (!memberPath.endsWith(".json")) continue;
+    try {
+      JSON.parse(utf8.decode(bytes));
+    } catch {
+      return { ok: false, refusal: `the archive member ${memberPath} is not readable JSON \u2014 these are not verbatim recorded envelopes` };
+    }
+  }
+  for (const rep of shape.reps) {
+    if (!members.has(`${rep}/get_metadata.json`)) {
+      return { ok: false, refusal: `the archive carries no get_metadata.json for the rep ${rep} \u2014 a set missing recorded metadata cannot be reconstructed` };
+    }
+  }
+  const derived = hashRecordingSet(enumeration, (p) => members.get(p), opts.sha256);
+  if (derived !== env.data.recordingSetHash) {
+    return { ok: false, refusal: `the archive does not re-derive its own declared recording-set hash (${derived.slice(0, 12)}\u2026 vs ${env.data.recordingSetHash.slice(0, 12)}\u2026)` };
+  }
+  if (opts.expectedSetHash !== void 0 && derived !== opts.expectedSetHash) {
+    return { ok: false, refusal: `the archive re-derives ${derived.slice(0, 12)}\u2026 but the publication's scored recording set is ${opts.expectedSetHash.slice(0, 12)}\u2026 \u2014 these are not the recordings the verdict was measured against` };
+  }
+  const extras = carriedExtrasHash(members, enumeration, opts.sha256);
+  if (extras !== env.data.carriedExtrasHash) {
+    return {
+      ok: false,
+      refusal: `the archive does not re-derive the digest of the recordings it carries outside the scored set (${extras.slice(0, 12)}\u2026 vs ${env.data.carriedExtrasHash.slice(0, 12)}\u2026) \u2014 the motion, interior geometry or bindings travelling with this set are not the ones it was packed with`
+    };
+  }
+  if (env.data.component !== shape.component) {
+    return { ok: false, refusal: `the archive claims component ${JSON.stringify(env.data.component)} but its recording-set.json says ${JSON.stringify(shape.component)}` };
+  }
+  if ((env.data.figmaFile ?? void 0) !== (shape.figmaFile ?? void 0)) {
+    return { ok: false, refusal: "the archive's declared figmaFile disagrees with its recording-set.json" };
+  }
+  for (const [memberPath, bytes] of members) {
+    if (!memberPath.endsWith("/rest_instances.json")) continue;
+    const rep = memberPath.slice(0, -"/rest_instances.json".length);
+    const check = restInstancesSelfCheck(rep, bytes, members, opts.sha256);
+    if (check !== void 0) return { ok: false, refusal: check };
+  }
+  return { ok: true, shape, setHash: derived, members };
+}
+function restInstancesSelfCheck(rep, bytes, members, sha2562) {
+  let parsed;
+  try {
+    parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    return `${rep}/rest_instances.json is not readable JSON`;
+  }
+  const va = parsed.verifiedAgainst;
+  if (va === void 0 || typeof va.metadataSha256 !== "string") return `${rep}/rest_instances.json carries no verifiedAgainst record`;
+  const pairs = [
+    [va.metadataSha256, `${rep}/get_metadata.json`],
+    ...va.screenshotSha256 !== void 0 ? [[va.screenshotSha256, `${rep}/get_screenshot.json`]] : [],
+    ...va.contextSha256 !== void 0 ? [[va.contextSha256, `${rep}/get_design_context.json`]] : []
+  ];
+  for (const [declared, memberPath] of pairs) {
+    const target = members.get(memberPath);
+    if (target === void 0) return `${rep}/rest_instances.json is verified against ${memberPath}, which the archive does not carry`;
+    if (typeof declared !== "string" || !SHA64.test(declared) || sha2562([target]) !== declared) {
+      return `${rep}/rest_instances.json does not verify against the carried ${memberPath} \u2014 carried enrichment must not outrank carried truth`;
+    }
+  }
+  return void 0;
+}
+function packRecordingArchive(fs4, opts) {
+  if (!fs4.exists("recording-set.json")) return { ok: false, refusal: "this directory holds no recording-set.json" };
+  const read = readSetShape(fs4.read("recording-set.json"));
+  if (!read.ok) return read;
+  const shape = read.shape;
+  const listRepSafe = (rep) => fs4.listRep(rep).filter((name) => safeSegment(name));
+  const enumeration = recordingSetEnumeration({ channeled: shape.channeled, reps: shape.reps }, { exists: fs4.exists, listRep: listRepSafe });
+  const paths = new Set(enumeration);
+  for (const extra of SET_LEVEL_EXTRAS) {
+    if (fs4.exists(extra)) paths.add(extra);
+  }
+  for (const rep of shape.reps) {
+    for (const extra of PER_REP_EXTRAS) {
+      if (fs4.exists(`${rep}/${extra}`)) paths.add(`${rep}/${extra}`);
+    }
+  }
+  const members = /* @__PURE__ */ new Map();
+  for (const p of paths) members.set(p, fs4.read(p));
+  const staleEnrichment = [];
+  for (const memberPath of [...members.keys()]) {
+    if (!memberPath.endsWith("/rest_instances.json")) continue;
+    const rep = memberPath.slice(0, -"/rest_instances.json".length);
+    if (restInstancesSelfCheck(rep, members.get(memberPath), members, opts.sha256) !== void 0) {
+      members.delete(memberPath);
+      staleEnrichment.push(memberPath);
+    }
+  }
+  const setHash = hashRecordingSet(enumeration, (p) => members.get(p), opts.sha256);
+  const envelope = {
+    version: RECORDING_ARCHIVE_VERSION,
+    component: shape.component,
+    ...shape.figmaFile !== void 0 ? { figmaFile: shape.figmaFile } : {},
+    recordingSetHash: setHash,
+    // Computed AFTER stale enrichment is dropped, so the digest covers
+    // what actually travels rather than what was on disk.
+    carriedExtrasHash: carriedExtrasHash(members, enumeration, opts.sha256),
+    files: [...members.keys()].sort().map((p) => ({ path: p, bytes: bytesToBase64(members.get(p)) }))
+  };
+  const envelopeText2 = JSON.stringify(envelope);
+  const check = validateRecordingArchive(envelopeText2, { sha256: opts.sha256, expectedSetHash: setHash });
+  if (!check.ok) return { ok: false, refusal: `the packed archive failed its own gate: ${check.refusal}` };
+  return { ok: true, envelopeText: envelopeText2, setHash, staleEnrichment };
+}
+var RECORDING_ARCHIVE_VERSION, MAX_ARCHIVE_MEMBERS, MAX_MEMBER_BYTES, SHA64, B64_ALPHABET, safeSegment, SET_LEVEL_EXTRAS, PER_REP_EXTRAS, RecordingArchiveEnvelopeSchema;
+var init_recording_archive = __esm({
+  "packages/metadata/src/recording-archive.ts"() {
+    "use strict";
+    init_bundle();
+    RECORDING_ARCHIVE_VERSION = 1;
+    MAX_ARCHIVE_MEMBERS = 4096;
+    MAX_MEMBER_BYTES = 5e6;
+    SHA64 = /^[0-9a-f]{64}$/;
+    B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    safeSegment = (s) => s !== "" && s !== "." && s !== ".." && s.length <= 200 && !/[/\\\0\s]/.test(s) && !s.startsWith(".");
+    SET_LEVEL_EXTRAS = ["get_motion_context.json"];
+    PER_REP_EXTRAS = ["get_metadata_interior.json", "rest_instances.json"];
+    RecordingArchiveEnvelopeSchema = z11.object({
+      version: z11.literal(RECORDING_ARCHIVE_VERSION),
+      component: z11.string().min(1).max(256),
+      figmaFile: z11.string().min(1).max(128).optional(),
+      recordingSetHash: z11.string().regex(SHA64),
+      /** The carried-but-unhashed members, digested (see
+       * `carriedExtrasHash`). Required: no v1 envelope has ever existed
+       * without it — the carrier has never shipped and migration 0011 is
+       * applied nowhere — so this is additive at zero cost rather than a
+       * version bump nobody would be able to interpret later. */
+      carriedExtrasHash: z11.string().regex(SHA64),
+      files: z11.array(z11.object({ path: z11.string().min(1).max(1024), bytes: z11.string() }).strict()).min(1).max(MAX_ARCHIVE_MEMBERS)
+    }).strict();
+  }
+});
+
+// packages/metadata/src/profile.ts
+import { z as z12 } from "zod";
 function readCodebaseProfile(raw) {
   return CodebaseProfileSchema.parse(JSON.parse(raw));
 }
@@ -7104,11 +7414,11 @@ var init_profile = __esm({
       maxCustomProperties: 5e3,
       maxComponents: 5e3
     };
-    CssCustomPropertyName = z11.string().min(3).max(200).regex(/^--[^\s{}();:'"]+$/u);
-    RelPath = z11.string().min(1).max(400).refine((p) => !p.startsWith("/") && !p.includes("\\") && !p.includes(".."), {
+    CssCustomPropertyName = z12.string().min(3).max(200).regex(/^--[^\s{}();:'"]+$/u);
+    RelPath = z12.string().min(1).max(400).refine((p) => !p.startsWith("/") && !p.includes("\\") && !p.includes(".."), {
       message: "path must be repo-relative POSIX"
     });
-    StylingDialectSchema = z11.enum([
+    StylingDialectSchema = z12.enum([
       "tailwind-v3",
       "tailwind-v4",
       "css-modules",
@@ -7123,26 +7433,26 @@ var init_profile = __esm({
       "styled-jsx",
       "shadcn-style"
     ]);
-    DialectEvidenceSchema = z11.object({
+    DialectEvidenceSchema = z12.object({
       dialect: StylingDialectSchema,
       /** A file proves a dialect is USED. A dependency only proves it is
        * INSTALLED — kept separate because a stale devDependency is not a
        * convention, and only file evidence may set `primary`. */
-      source: z11.enum(["file", "dependency"]),
-      detail: z11.string().max(200)
+      source: z12.enum(["file", "dependency"]),
+      detail: z12.string().max(200)
     });
-    CustomPropertyDeclarationSchema = z11.object({
+    CustomPropertyDeclarationSchema = z12.object({
       file: RelPath,
-      line: z11.number().int().nonnegative(),
-      selector: z11.string().max(300),
-      scope: z11.enum(["root", "theme-block", "class", "id", "attribute", "media", "supports", "other"]),
+      line: z12.number().int().nonnegative(),
+      selector: z12.string().max(300),
+      scope: z12.enum(["root", "theme-block", "class", "id", "attribute", "media", "supports", "other"]),
       /** Present only for conditional at-rules, e.g. "(prefers-color-scheme: dark)". */
-      condition: z11.string().max(300).optional(),
-      value: z11.string().max(500),
+      condition: z12.string().max(300).optional(),
+      value: z12.string().max(500),
       /** A terminal literal, when the var() chain could be followed without
        * leaving this declaration's scope group. */
-      resolved: z11.string().max(500).nullable(),
-      resolvedVia: z11.enum([
+      resolved: z12.string().max(500).nullable(),
+      resolvedVia: z12.enum([
         "literal",
         "alias-chain",
         /** Target is declared in the scan, but only under a different scope —
@@ -7157,11 +7467,11 @@ var init_profile = __esm({
         "unresolved-function"
       ])
     });
-    CustomPropertySchema = z11.object({
+    CustomPropertySchema = z12.object({
       name: CssCustomPropertyName,
-      declarations: z11.array(CustomPropertyDeclarationSchema).min(1).max(64)
+      declarations: z12.array(CustomPropertyDeclarationSchema).min(1).max(64)
     });
-    ComponentOutcomeSchema = z11.enum([
+    ComponentOutcomeSchema = z12.enum([
       "parsed",
       "parsed-no-props",
       "no-component-found",
@@ -7169,7 +7479,7 @@ var init_profile = __esm({
       "skipped-too-large",
       "skipped-cap"
     ]);
-    ComponentBlindSpotSchema = z11.enum([
+    ComponentBlindSpotSchema = z12.enum([
       "multiple-components-in-file",
       "re-export-only",
       "cva-variants",
@@ -7177,40 +7487,40 @@ var init_profile = __esm({
       "hoc-wrapper",
       "props-from-imported-types"
     ]);
-    ComponentEntrySchema = z11.object({
+    ComponentEntrySchema = z12.object({
       file: RelPath,
       outcome: ComponentOutcomeSchema,
       /** Identifier-shaped, from the source. Absent for anonymous exports. */
-      names: z11.array(z11.string().max(120).regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/)).max(40),
-      propCount: z11.number().int().nonnegative(),
-      exportStyle: z11.enum(["named", "default", "both", "none"]),
-      blindSpots: z11.array(ComponentBlindSpotSchema).max(8)
-    });
-    HistogramSchema = z11.object({
-      counts: z11.record(z11.string().max(60), z11.number().int().nonnegative()),
-      total: z11.number().int().nonnegative(),
-      dominant: z11.string().max(60).nullable()
-    });
-    FormattingSchema = z11.object({
-      source: z11.enum(["prettier-config", "editorconfig", "source-histogram", "none"]),
-      indentStyle: z11.enum(["space", "tab"]).nullable(),
-      indentWidth: z11.number().int().min(1).max(16).nullable(),
-      quotes: z11.enum(["single", "double"]).nullable(),
-      semicolons: z11.boolean().nullable(),
-      trailingComma: z11.enum(["none", "es5", "all"]).nullable()
-    });
-    CodebaseProfileSchema = z11.object({
-      profileVersion: z11.literal(CODEBASE_PROFILE_VERSION),
+      names: z12.array(z12.string().max(120).regex(/^[A-Za-z_$][A-Za-z0-9_$]*$/)).max(40),
+      propCount: z12.number().int().nonnegative(),
+      exportStyle: z12.enum(["named", "default", "both", "none"]),
+      blindSpots: z12.array(ComponentBlindSpotSchema).max(8)
+    });
+    HistogramSchema = z12.object({
+      counts: z12.record(z12.string().max(60), z12.number().int().nonnegative()),
+      total: z12.number().int().nonnegative(),
+      dominant: z12.string().max(60).nullable()
+    });
+    FormattingSchema = z12.object({
+      source: z12.enum(["prettier-config", "editorconfig", "source-histogram", "none"]),
+      indentStyle: z12.enum(["space", "tab"]).nullable(),
+      indentWidth: z12.number().int().min(1).max(16).nullable(),
+      quotes: z12.enum(["single", "double"]).nullable(),
+      semicolons: z12.boolean().nullable(),
+      trailingComma: z12.enum(["none", "es5", "all"]).nullable()
+    });
+    CodebaseProfileSchema = z12.object({
+      profileVersion: z12.literal(CODEBASE_PROFILE_VERSION),
       /** The scan's identity. Sha256 over every file actually read (path + bytes),
        * in sorted order — so two scans of the same tree agree and a changed tree
        * does not. */
-      inputsHash: z11.string().regex(/^[0-9a-f]{64}$/),
-      scannedAt: z11.string(),
+      inputsHash: z12.string().regex(/^[0-9a-f]{64}$/),
+      scannedAt: z12.string(),
       /** Whether the walk finished without hitting a cap. When false,
        * `limitsHit` names which. */
-      complete: z11.boolean(),
-      limitsHit: z11.array(
-        z11.enum([
+      complete: z12.boolean(),
+      limitsHit: z12.array(
+        z12.enum([
           "files",
           "depth",
           "totalBytes",
@@ -7221,51 +7531,51 @@ var init_profile = __esm({
           "stylingEvidence"
         ])
       ).max(8),
-      read: z11.object({
-        files: z11.number().int().nonnegative(),
-        bytes: z11.number().int().nonnegative(),
-        packages: z11.number().int().nonnegative(),
+      read: z12.object({
+        files: z12.number().int().nonnegative(),
+        bytes: z12.number().int().nonnegative(),
+        packages: z12.number().int().nonnegative(),
         /** Files the walk saw but could not parse, with why. */
-        unparsed: z11.array(
-          z11.object({
+        unparsed: z12.array(
+          z12.object({
             file: RelPath,
-            reason: z11.enum(["preprocessor-syntax", "parse-error", "too-large", "unreadable"])
+            reason: z12.enum(["preprocessor-syntax", "parse-error", "too-large", "unreadable"])
           })
         ).max(500)
       }),
-      styling: z11.object({
+      styling: z12.object({
         /** Set ONLY when exactly one dialect has FILE evidence. Never guessed —
          * a repo with three styling systems gets null and `ambiguous: true`,
          * which is the truth. */
         primary: StylingDialectSchema.nullable(),
-        ambiguous: z11.boolean(),
-        detected: z11.array(DialectEvidenceSchema).max(40)
+        ambiguous: z12.boolean(),
+        detected: z12.array(DialectEvidenceSchema).max(40)
       }),
-      css: z11.object({
-        customProperties: z11.array(CustomPropertySchema).max(PROFILE_LIMITS.maxCustomProperties),
+      css: z12.object({
+        customProperties: z12.array(CustomPropertySchema).max(PROFILE_LIMITS.maxCustomProperties),
         /** Names rejected by the ident class, and values too long to carry.
          * Counted so their absence is never read as "the repo declares none". */
-        droppedNames: z11.number().int().nonnegative(),
-        droppedValues: z11.number().int().nonnegative()
+        droppedNames: z12.number().int().nonnegative(),
+        droppedValues: z12.number().int().nonnegative()
       }),
-      components: z11.object({
-        entries: z11.array(ComponentEntrySchema).max(PROFILE_LIMITS.maxComponents),
+      components: z12.object({
+        entries: z12.array(ComponentEntrySchema).max(PROFILE_LIMITS.maxComponents),
         fileNaming: HistogramSchema,
         directoryLayout: HistogramSchema,
         exportStyle: HistogramSchema,
         classNameStyle: HistogramSchema,
         colocation: HistogramSchema,
-        barrelFiles: z11.number().int().nonnegative(),
-        refForwarding: z11.object({
-          forwardRef: z11.number().int().nonnegative(),
-          asChild: z11.number().int().nonnegative()
+        barrelFiles: z12.number().int().nonnegative(),
+        refForwarding: z12.object({
+          forwardRef: z12.number().int().nonnegative(),
+          asChild: z12.number().int().nonnegative()
         }),
         formatting: FormattingSchema
       }),
       /** Capability limits this scan hit, in the user's words. A Tailwind v3
        * theme lives in a JS config we refuse to execute; that is a real,
        * disclosed limit, not an oversight. */
-      disclosures: z11.array(z11.string().max(400)).max(30)
+      disclosures: z12.array(z12.string().max(400)).max(30)
     });
   }
 });
@@ -7282,6 +7592,7 @@ var init_src4 = __esm({
     init_verify_report();
     init_published_surface();
     init_motion_css();
+    init_recording_archive();
     init_profile();
   }
 });
@@ -9106,6 +9417,20 @@ var init_publish_client = __esm({
           retryable: true
         });
       }
+      resolveRecordings(input) {
+        const query = new URLSearchParams({ component: input.component, ...input.figmaFile === void 0 ? {} : { figmaFile: input.figmaFile } });
+        return this.request("GET", `/api/recordings?${query.toString()}`, { body: "", contentType: "application/json", retryable: true });
+      }
+      downloadRecordings(input) {
+        return this.requestBytes("GET", `/api/publications/${encodeURIComponent(input.publicationId)}/recordings`);
+      }
+      carryRecordings(input) {
+        return this.request("PUT", `/api/publications/${encodeURIComponent(input.publicationId)}/recordings`, {
+          body: new TextEncoder().encode(input.envelopeText),
+          contentType: "application/octet-stream",
+          retryable: true
+        });
+      }
       commit(input) {
         return this.json("POST", `/api/publications/${encodeURIComponent(input.publicationId)}/commit`, {}, true);
       }
@@ -9132,7 +9457,15 @@ var init_publish_client = __esm({
       json(method, pathname, body, retryable = false) {
         return this.request(method, pathname, { body: JSON.stringify(body), contentType: "application/json", retryable });
       }
-      async request(method, pathname, init) {
+      /**
+       * The transport, minus any opinion about what comes back.
+       *
+       * Split out when the recordings carrier needed a response read as
+       * BYTES rather than JSON: retries, timeouts and the unreachable-host
+       * refusal are properties of the call, not of the body format, and two
+       * copies of a retry policy is two policies.
+       */
+      async attempt(method, pathname, init) {
         let response;
         let lastError = "";
         const attempts = init.retryable === true ? RETRIES : 1;
@@ -9168,6 +9501,12 @@ var init_publish_client = __esm({
           }
           break;
         }
+        return { ok: true, response };
+      }
+      async request(method, pathname, init) {
+        const sent = await this.attempt(method, pathname, init);
+        if (!sent.ok) return sent;
+        const { response } = sent;
         const text = await response.text();
         let parsed;
         try {
@@ -9179,15 +9518,46 @@ var init_publish_client = __esm({
             refusal: `${this.origin} answered with ${String(response.status)} and something that is not JSON, so it is probably not a Tendril portal`
           };
         }
-        const record = parsed ?? {};
         if (response.ok) return { ok: true, value: parsed };
+        return this.refusalFrom(response.status, parsed);
+      }
+      /**
+       * A response read as BYTES — the recording archive, which is a
+       * document to store rather than a shape this client owns.
+       *
+       * The SUCCESS path never parses; the refusal path still does, because
+       * a portal refusal is JSON whatever the caller asked for.
+       */
+      async requestBytes(method, pathname) {
+        const sent = await this.attempt(method, pathname, { body: "", contentType: "application/json", retryable: true });
+        if (!sent.ok) return sent;
+        const { response } = sent;
+        if (response.ok) return { ok: true, value: new Uint8Array(await response.arrayBuffer()) };
+        const text = await response.text();
+        let parsed;
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          return {
+            ok: false,
+            status: response.status,
+            refusal: `${this.origin} answered with ${String(response.status)} and something that is not JSON, so it is probably not a Tendril portal`
+          };
+        }
+        return this.refusalFrom(response.status, parsed);
+      }
+      refusalFrom(status, parsed) {
+        const record = parsed ?? {};
         return {
           ok: false,
-          status: response.status,
-          refusal: typeof record["refusal"] === "string" ? record["refusal"] : `the portal refused with ${String(response.status)}`,
+          status,
+          refusal: typeof record["refusal"] === "string" ? record["refusal"] : `the portal refused with ${String(status)}`,
           ...Array.isArray(record["detail"]) ? { detail: record["detail"] } : {},
           ...Array.isArray(record["missing"]) ? { missing: record["missing"] } : {},
-          ...isRecord(record["needsConfirmation"]) ? { needsConfirmation: record["needsConfirmation"] } : {}
+          ...isRecord(record["needsConfirmation"]) ? { needsConfirmation: record["needsConfirmation"] } : {},
+          ...Array.isArray(record["candidates"]) ? { candidates: record["candidates"] } : {},
+          ...record["alreadyCarried"] === true ? { alreadyCarried: true } : {},
+          ...typeof record["setHash"] === "string" ? { setHash: record["setHash"] } : {}
         };
       }
     };
@@ -9642,7 +10012,7 @@ var init_doctor = __esm({
 });
 
 // packages/llm/src/model-config.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function resolveModel(config, requestedId) {
   const entry = config.allowlist.find((m) => m.id === requestedId);
   if (entry) return { ok: true, entry };
@@ -9664,46 +10034,46 @@ var ModelStatusSchema, ModelEntrySchema, ModelConfigSchema, DEFAULT_MODEL_CONFIG
 var init_model_config = __esm({
   "packages/llm/src/model-config.ts"() {
     "use strict";
-    ModelStatusSchema = z12.enum(["verified", "degraded"]);
-    ModelEntrySchema = z12.object({
+    ModelStatusSchema = z13.enum(["verified", "degraded"]);
+    ModelEntrySchema = z13.object({
       /** OpenRouter model id, e.g. "deepseek/deepseek-v4-flash". */
-      id: z12.string(),
+      id: z13.string(),
       status: ModelStatusSchema,
       /** Roles this model may fill in the pipeline. */
-      roles: z12.array(z12.enum(["bulk", "polish"])),
+      roles: z13.array(z13.enum(["bulk", "polish"])),
       /** Accepts image input. Text-only models get the screenshot dropped with a
        * warning instead of a provider 404 (Carbon run 1 finding). */
-      vision: z12.boolean().default(false),
+      vision: z13.boolean().default(false),
       /** Engine-adapter params shipped WITH the entry (ADR-011 §2): the
        * eval-proven settings ride the allowlist so users never rediscover a
        * model's quirks at their own expense (K2.7-code burned its whole
        * completion budget on mandatory reasoning and emitted nothing). */
-      adapter: z12.object({
+      adapter: z13.object({
         /** Minimum completion budget the model needs to emit full files. */
-        maxTokens: z12.number().optional(),
+        maxTokens: z13.number().optional(),
         /** "mandatory": provider refuses reasoning-off; budget accordingly. */
-        reasoning: z12.enum(["mandatory", "optional", "none"]).optional()
+        reasoning: z13.enum(["mandatory", "optional", "none"]).optional()
       }).optional(),
       /** One-line pointer to the evidence behind `status` (which eval, when).
        * Pricing intentionally has no static field — the resolution path is
        * the provider's models endpoint at run time (ADR-011 §2). */
-      evidence: z12.string().optional()
+      evidence: z13.string().optional()
     });
-    ModelConfigSchema = z12.object({
+    ModelConfigSchema = z13.object({
       /** Default model for codegen + repair (pipeline steps 4–5, facts path). */
-      bulk: z12.string(),
+      bulk: z13.string(),
       /** Optional premium polish model (pipeline step 6, aesthetics/naming only). */
-      polish: z12.string().optional(),
+      polish: z13.string().optional(),
       /** ADR-011 §2 default-model pointer for the curated recorded-truth
        * engine (a separate axis from the facts-era `bulk`; `generate` flips
        * to it in ADR-010 slice 6). Moves only via the reference-corpus gate. */
-      curatedDefault: z12.string().optional(),
+      curatedDefault: z13.string().optional(),
       /** ADR-011 §3a Rung-1 escalation target: the model the curated loop
        * offers for configs still sub-bar at plateau. Designated ONLY via
        * the register's gate (a real curated cert-target run on the measured
        * escalation case); empty means no Rung-1 offer, never a default. */
-      escalationTarget: z12.string().optional(),
-      allowlist: z12.array(ModelEntrySchema)
+      escalationTarget: z13.string().optional(),
+      allowlist: z13.array(ModelEntrySchema)
     });
     DEFAULT_MODEL_CONFIG = {
       bulk: "google/gemini-3.1-flash-lite",
@@ -9882,7 +10252,7 @@ var init_openrouter = __esm({
 });
 
 // packages/llm/src/semantics.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function portable(node) {
   if (Array.isArray(node)) return node.map(portable);
   if (typeof node !== "object" || node === null) return node;
@@ -9906,7 +10276,7 @@ function portable(node) {
   return out;
 }
 function toPortableJsonSchema(schema) {
-  return portable(z13.toJSONSchema(schema));
+  return portable(z14.toJSONSchema(schema));
 }
 function semanticsJsonSchema() {
   return toPortableJsonSchema(SemanticsSchema);
@@ -9921,18 +10291,18 @@ var PropTypeSchema, SemanticsSchema, CodegenOutputSchema, DocsOutputSchema;
 var init_semantics = __esm({
   "packages/llm/src/semantics.ts"() {
     "use strict";
-    PropTypeSchema = z13.discriminatedUnion("kind", [
-      z13.object({ kind: z13.literal("enum"), values: z13.array(z13.string()).min(1) }),
-      z13.object({ kind: z13.literal("boolean") }),
-      z13.object({ kind: z13.literal("string") }),
-      z13.object({ kind: z13.literal("reactNode") }),
-      z13.object({ kind: z13.literal("handler") })
+    PropTypeSchema = z14.discriminatedUnion("kind", [
+      z14.object({ kind: z14.literal("enum"), values: z14.array(z14.string()).min(1) }),
+      z14.object({ kind: z14.literal("boolean") }),
+      z14.object({ kind: z14.literal("string") }),
+      z14.object({ kind: z14.literal("reactNode") }),
+      z14.object({ kind: z14.literal("handler") })
     ]);
-    SemanticsSchema = z13.object({
+    SemanticsSchema = z14.object({
       /** PascalCase component name. */
-      componentName: z13.string().regex(/^[A-Z][A-Za-z0-9]*$/),
+      componentName: z14.string().regex(/^[A-Z][A-Za-z0-9]*$/),
       /** Semantic HTML element for the root node. */
-      element: z13.enum([
+      element: z14.enum([
         "button",
         "a",
         "div",
@@ -9946,33 +10316,33 @@ var init_semantics = __esm({
         "ul",
         "li"
       ]),
-      props: z13.array(
-        z13.object({
-          name: z13.string().regex(/^[a-z][A-Za-z0-9]*$/),
+      props: z14.array(
+        z14.object({
+          name: z14.string().regex(/^[a-z][A-Za-z0-9]*$/),
           type: PropTypeSchema,
-          required: z13.boolean(),
+          required: z14.boolean(),
           /** nullish, not optional: models routinely encode "no default" as
            * null (observed live: kimi-k2.7-code, Carbon run 8). */
-          defaultValue: z13.string().nullish()
+          defaultValue: z14.string().nullish()
         })
       ),
       /** Variant axes that become discriminated unions (invalid combos must not compile). */
-      discriminatedUnions: z13.array(
-        z13.object({
-          discriminant: z13.string(),
-          arms: z13.array(
-            z13.object({
-              value: z13.string(),
+      discriminatedUnions: z14.array(
+        z14.object({
+          discriminant: z14.string(),
+          arms: z14.array(
+            z14.object({
+              value: z14.string(),
               /** Props only valid for this arm. */
-              extraProps: z13.array(z13.string())
+              extraProps: z14.array(z14.string())
             })
           )
         })
       ),
-      a11y: z13.object({
-        role: z13.string().nullish(),
-        keyboard: z13.array(z13.string()),
-        aria: z13.array(z13.string())
+      a11y: z14.object({
+        role: z14.string().nullish(),
+        keyboard: z14.array(z14.string()),
+        aria: z14.array(z14.string())
       }),
       /**
        * How each Figma axis value is realized through the generated API —
@@ -9981,29 +10351,29 @@ var init_semantics = __esm({
        * The visual fact check verifies these claims against real renders, so a
        * wrong mapping fails measurement instead of being trusted.
        */
-      variantMapping: z13.array(
-        z13.object({
-          axis: z13.string(),
-          value: z13.string(),
-          prop: z13.string(),
-          propValue: z13.union([z13.string(), z13.boolean()])
+      variantMapping: z14.array(
+        z14.object({
+          axis: z14.string(),
+          value: z14.string(),
+          prop: z14.string(),
+          propValue: z14.union([z14.string(), z14.boolean()])
         })
       )
     });
-    CodegenOutputSchema = z13.object({
+    CodegenOutputSchema = z14.object({
       /** Component source (.tsx). Token-only styling via the provided CSS file. */
-      tsx: z13.string().min(1),
+      tsx: z14.string().min(1),
       /** Stylesheet (.css) — themable properties reference var(--token) only. */
-      css: z13.string().min(1)
+      css: z14.string().min(1)
     });
-    DocsOutputSchema = z13.object({
-      usageMd: z13.string().min(1),
-      aiHints: z13.object({ selectionCriteria: z13.array(z13.string()).min(1) }),
-      antiPatterns: z13.array(
-        z13.object({ scenario: z13.string(), reason: z13.string(), alternative: z13.string() })
+    DocsOutputSchema = z14.object({
+      usageMd: z14.string().min(1),
+      aiHints: z14.object({ selectionCriteria: z14.array(z14.string()).min(1) }),
+      antiPatterns: z14.array(
+        z14.object({ scenario: z14.string(), reason: z14.string(), alternative: z14.string() })
       ),
-      composition: z13.array(z13.string()),
-      examples: z13.array(z13.object({ title: z13.string(), code: z13.string() }))
+      composition: z14.array(z14.string()),
+      examples: z14.array(z14.object({ title: z14.string(), code: z14.string() }))
     });
   }
 });
@@ -10729,7 +11099,7 @@ var init_engine_curated = __esm({
 // packages/generate/src/loop.ts
 import { existsSync as existsSync27, mkdirSync as mkdirSync8, readFileSync as readFileSync24, renameSync, writeFileSync as writeFileSync12 } from "node:fs";
 import path34 from "node:path";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function objective(scores, behaviors) {
   const vals = scores.map((s) => Math.min(s.similarity, s.inkRecall));
   return [
@@ -10928,42 +11298,42 @@ var init_loop2 = __esm({
   "packages/generate/src/loop.ts"() {
     "use strict";
     better = (a, b) => a[0] !== b[0] ? a[0] > b[0] : a[1] !== b[1] ? a[1] > b[1] : a[2] > b[2];
-    RegionSchema = z14.object({ x0: z14.number(), y0: z14.number(), x1: z14.number(), y1: z14.number(), density: z14.number() });
-    ConfigScoreSchema = z14.object({
-      rep: z14.string(),
-      similarity: z14.number(),
-      inkRecall: z14.number(),
-      pass: z14.boolean(),
-      error: z14.string().optional(),
+    RegionSchema = z15.object({ x0: z15.number(), y0: z15.number(), x1: z15.number(), y1: z15.number(), density: z15.number() });
+    ConfigScoreSchema = z15.object({
+      rep: z15.string(),
+      similarity: z15.number(),
+      inkRecall: z15.number(),
+      pass: z15.boolean(),
+      error: z15.string().optional(),
       region: RegionSchema.optional()
     });
-    BehaviorResultSchema = z14.object({ id: z14.string(), pass: z14.boolean(), detail: z14.string().optional() });
-    LoopStateSchema = z14.object({
-      version: z14.literal(1),
-      spentUsd: z14.number(),
-      attempts: z14.array(
-        z14.object({
-          candidate: z14.object({
-            files: z14.record(z14.string(), z14.string()),
-            raw: z14.string().optional(),
-            usage: z14.object({ usd: z14.number(), inTokens: z14.number(), outTokens: z14.number(), modelMs: z14.number(), finishReason: z14.string().optional() }).optional()
+    BehaviorResultSchema = z15.object({ id: z15.string(), pass: z15.boolean(), detail: z15.string().optional() });
+    LoopStateSchema = z15.object({
+      version: z15.literal(1),
+      spentUsd: z15.number(),
+      attempts: z15.array(
+        z15.object({
+          candidate: z15.object({
+            files: z15.record(z15.string(), z15.string()),
+            raw: z15.string().optional(),
+            usage: z15.object({ usd: z15.number(), inTokens: z15.number(), outTokens: z15.number(), modelMs: z15.number(), finishReason: z15.string().optional() }).optional()
           }),
-          rulerScore: z14.object({ passCount: z14.number(), floor: z14.number(), mean: z14.number() }),
-          accepted: z14.boolean(),
-          feedback: z14.string()
+          rulerScore: z15.object({ passCount: z15.number(), floor: z15.number(), mean: z15.number() }),
+          accepted: z15.boolean(),
+          feedback: z15.string()
         })
       ),
-      iterations: z14.array(
-        z14.object({
-          iter: z14.number(),
-          usd: z14.number(),
-          modelMs: z14.number().optional(),
-          scoreMs: z14.number().optional(),
-          objective: z14.tuple([z14.number(), z14.number(), z14.number()]),
-          accepted: z14.boolean(),
-          scores: z14.array(ConfigScoreSchema),
-          behaviors: z14.array(BehaviorResultSchema).optional(),
-          parseError: z14.string().optional()
+      iterations: z15.array(
+        z15.object({
+          iter: z15.number(),
+          usd: z15.number(),
+          modelMs: z15.number().optional(),
+          scoreMs: z15.number().optional(),
+          objective: z15.tuple([z15.number(), z15.number(), z15.number()]),
+          accepted: z15.boolean(),
+          scores: z15.array(ConfigScoreSchema),
+          behaviors: z15.array(BehaviorResultSchema).optional(),
+          parseError: z15.string().optional()
         })
       )
     });
@@ -12355,28 +12725,13 @@ function recordingSetHash(setDir, configs) {
     channeled = JSON.parse(readFileSync27(path37.join(setDir, "recording-set.json"), "utf8")).channel !== void 0;
   } catch {
   }
-  const relPaths = [];
-  const setLevel = ["recording-set.json", "completeness-manifest.json", "get_variable_defs.json", "get_metadata.json", ...channeled ? ["get_motion_context.json"] : []];
-  for (const name of setLevel) {
-    if (existsSync30(path37.join(setDir, name))) relPaths.push(name);
-  }
-  const perRep = [
-    "get_design_context.json",
-    "get_metadata.json",
-    "get_screenshot.json",
-    "get_variable_defs.json",
-    ...channeled ? ["get_metadata_interior.json", "rest_nodes.json", "rest_metadata.json", "rest_screenshot.json"] : []
-  ];
-  for (const cfg of configs) {
-    for (const f of perRep) {
-      if (existsSync30(path37.join(setDir, cfg.rep, f))) relPaths.push(`${cfg.rep}/${f}`);
-    }
-    if (existsSync30(path37.join(setDir, cfg.rep))) {
-      for (const asset of readdirSync11(path37.join(setDir, cfg.rep)).filter((f) => f.startsWith("asset-"))) {
-        relPaths.push(`${cfg.rep}/${asset}`);
-      }
+  const relPaths = recordingSetEnumeration(
+    { channeled, reps: configs.map((c) => c.rep) },
+    {
+      exists: (p) => existsSync30(path37.join(setDir, p)),
+      listRep: (rep) => existsSync30(path37.join(setDir, rep)) ? readdirSync11(path37.join(setDir, rep)) : []
     }
-  }
+  );
   return hashRecordingSet(
     relPaths,
     (p) => new Uint8Array(readFileSync27(path37.join(setDir, p))),
@@ -13043,7 +13398,7 @@ function composedPins(hostSet, libraryRoots) {
         failures.push(`${rel}: partner bundle manifest at ${bundleDir} became unreadable`);
         continue;
       }
-      if (!safeSegment(manifest.name) || !safeSegment(manifest.entry)) {
+      if (!safeSegment2(manifest.name) || !safeSegment2(manifest.entry)) {
         failures.push(
           `${rel}: partner bundle at ${bundleDir} declares an unsafe name/entry (${JSON.stringify(manifest.name)} / ${JSON.stringify(manifest.entry)}) \u2014 refused; both must be a single plain path segment`
         );
@@ -13148,7 +13503,7 @@ function composedChecks(candidateDir, hostEntry, pins) {
     }
     const wrong = [];
     for (const f of pin.moduleFiles) {
-      if (!safeSegment(f.name)) {
+      if (!safeSegment2(f.name)) {
         wrong.push(`${f.name} refused (not a plain path segment)`);
         continue;
       }
@@ -13207,7 +13562,7 @@ function regionOverrides(hostSet, partnerSet, instances) {
   }
   return out;
 }
-var composedModuleDir, safeSegment, MAX_PINNED_FILE_BYTES, CONTEXT_LAYOUT_TOKENS;
+var composedModuleDir, safeSegment2, MAX_PINNED_FILE_BYTES, CONTEXT_LAYOUT_TOKENS;
 var init_compose_pins = __esm({
   "packages/generate/src/compose-pins.ts"() {
     "use strict";
@@ -13216,7 +13571,7 @@ var init_compose_pins = __esm({
     init_brief();
     init_bundle_emit();
     composedModuleDir = (partnerName) => path38.posix.join("composed", partnerName);
-    safeSegment = (s) => /^[A-Za-z0-9][A-Za-z0-9._ -]*$/.test(s) && !s.includes("..");
+    safeSegment2 = (s) => /^[A-Za-z0-9][A-Za-z0-9._ -]*$/.test(s) && !s.includes("..");
     MAX_PINNED_FILE_BYTES = 1024 * 1024;
     CONTEXT_LAYOUT_TOKENS = /* @__PURE__ */ new Set(["shrink-0", "grow", "flex-1", "basis-0", "self-stretch", "w-full", "h-full"]);
   }
@@ -18750,7 +19105,7 @@ import { existsSync as existsSync43, mkdtempSync as mkdtempSync3, readFileSync a
 import os8 from "node:os";
 import path53 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 function sourceHash() {
   const dir = path53.dirname(fileURLToPath6(import.meta.url));
   const h = createHash12("sha256");
@@ -18768,23 +19123,23 @@ var init_server = __esm({
     CLI_BIN = path53.join(REPO_ROOT3, "packages", "cli", "src", "bin.ts");
     BUNDLED_CLI = path53.join(path53.dirname(fileURLToPath6(import.meta.url)), "tendril.js");
     CLI_SPAWN = existsSync43(BUNDLED_CLI) ? { cmd: process.execPath, prefix: [BUNDLED_CLI] } : { cmd: "npx", prefix: ["tsx", CLI_BIN] };
-    str = (d) => z15.string().describe(d);
-    optStr = (d) => z15.string().optional().describe(d);
+    str = (d) => z16.string().describe(d);
+    optStr = (d) => z16.string().optional().describe(d);
     TOOLS = [
       {
         name: "tendril_record_plan",
         description: "ENTRY POINT for implementing/building a React component from a Figma design or figma.com URL \u2014 start the Tendril pipeline here (after loading the tendril skill, if installed). Plans a recording session: computes the rep queue (anchor + one-factor + conflict crosses) from the verbatim get_metadata response (pass its blocks via metadataParts \u2014 no file to write) and persists the set manifest. Resumes if the set already exists. The output may carry USER QUESTIONS \u2014 defaultsToConfirm (which pose is the component's default) or a multiple-component-sets error (which set to record): render them to a present user and apply the answers via `defaults` / `componentSet`; non-interactive runs follow each question's stated fallback. It may also carry `interactionStatesToConfirm` \u2014 the recording holds no hover/focus/pressed state, so nothing shows how the component behaves when someone uses it: say its `statement` and `designFix` in that SAME one message (the fix is a Figma variant, not code). It is a disclosure, not a gate \u2014 no answer is required and recording proceeds regardless. The output also carries `feasibilityCheck`: the call arithmetic for this queue plus the free `whoami` check that turns it into a verdict \u2014 complete that handshake BEFORE the first recording call, and surface the verdict to the user when the set does not fit their daily allowance.",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("recording set directory to create/resume"),
           component: str("component/system name"),
           // Parts array FIRST, same reason as ingest_rep: real responses
           // are usually multi-block, and the file param made plan the ONE
           // remaining hand-built-envelope entry point (run 10: the agent
           // wrote the file twice — once as text, once as JSON envelope).
-          metadataParts: z15.array(z15.string()).optional().describe("the frame-level get_metadata response blocks, every block in order, each verbatim \u2014 never hand-join or save them yourself; this is the NORMAL param"),
+          metadataParts: z16.array(z16.string()).optional().describe("the frame-level get_metadata response blocks, every block in order, each verbatim \u2014 never hand-join or save them yourself; this is the NORMAL param"),
           metadata: optStr("ONLY when get_metadata genuinely returned one single block: its text verbatim (otherwise use metadataParts)"),
-          metadataFiles: z15.array(z15.string()).optional().describe('saved verbatim get_metadata envelope file paths \u2014 JSON shape {"content":[{"type":"text","text":"<frame \u2026>"}]}; optionally <file>@<frameId>. Prefer metadataParts: no file to write'),
-          defaults: z15.array(z15.string()).optional().describe(`axis defaults as "Axis=Value" (from the user's defaultsToConfirm answers; may re-plan a set with nothing recorded yet)`),
+          metadataFiles: z16.array(z16.string()).optional().describe('saved verbatim get_metadata envelope file paths \u2014 JSON shape {"content":[{"type":"text","text":"<frame \u2026>"}]}; optionally <file>@<frameId>. Prefer metadataParts: no file to write'),
+          defaults: z16.array(z16.string()).optional().describe(`axis defaults as "Axis=Value" (from the user's defaultsToConfirm answers; may re-plan a set with nothing recorded yet)`),
           componentSet: optStr("record only this component set (the user's pick from a multiple-component-sets error)"),
           figmaFile: optStr("the Figma file key from the design URL you were handed \u2014 figma.com/design/<KEY>/\u2026, pass exactly <KEY>. ALWAYS pass it on a fresh plan: it is the set's recorded file identity for cross-bundle composition (ADR-013), captured at plan time only and never backfillable later")
         }),
@@ -18820,10 +19175,10 @@ var init_server = __esm({
       {
         name: "tendril_permissions",
         description: "Install the Claude Code permission allowlist for the Tendril pipeline (write: true \u2014 merges the MCP per-tool entries, the run's shell surface, and project-scoped Write/Edit with deny guards for ./.claude and ./.git into the project's .claude/settings.local.json, idempotent, never touches other keys), or list the entries without writing. The shell/Write grants are CONVENIENCE, not a security boundary \u2014 the output's note names exactly what they trade; RELAY it with the offer. OFFER THIS AT PIPELINE START whenever NO merged Claude settings file (project .claude/settings.local.json or .claude/settings.json, or user ~/.claude/settings.json) contains tendril MCP entries \u2014 plugin installs use mcp__plugin_tendril_tendril__*, direct claude-mcp-add installs use mcp__<server>__* \u2014 when this session's tool names differ from the plugin defaults, pass figmaPrefix/tendrilPrefix with the prefixes you actually see, or the written entries never match. A FILE check, never prompt-watching \u2014 agents cannot observe permission prompts. ONE approval here replaces a prompt per pipeline call. Never run it unoffered; the user must reload the session for new settings to apply \u2014 say so.",
-        schema: z15.object({
-          write: z15.boolean().optional().describe("true = install into .claude/settings.local.json (the point of this tool); false/absent = just return the entries"),
-          figmaPrefix: z15.string().optional().describe("The Figma server's entry prefix AS THIS SESSION NAMES ITS TOOLS \u2014 the part before __get_metadata (e.g. mcp__figma-remote, mcp__plugin_figma_figma). Pass it whenever the session's Figma tools are not mcp__plugin_figma_figma__* \u2014 entries written under the wrong prefix never match anything (measured: six dead entries in a figma-remote session)."),
-          tendrilPrefix: z15.string().optional().describe("Same for the tendril server when this session's tendril tools are not mcp__plugin_tendril_tendril__* (e.g. mcp__tendril for claude mcp add installs).")
+        schema: z16.object({
+          write: z16.boolean().optional().describe("true = install into .claude/settings.local.json (the point of this tool); false/absent = just return the entries"),
+          figmaPrefix: z16.string().optional().describe("The Figma server's entry prefix AS THIS SESSION NAMES ITS TOOLS \u2014 the part before __get_metadata (e.g. mcp__figma-remote, mcp__plugin_figma_figma). Pass it whenever the session's Figma tools are not mcp__plugin_figma_figma__* \u2014 entries written under the wrong prefix never match anything (measured: six dead entries in a figma-remote session)."),
+          tendrilPrefix: z16.string().optional().describe("Same for the tendril server when this session's tendril tools are not mcp__plugin_tendril_tendril__* (e.g. mcp__tendril for claude mcp add installs).")
         }),
         argv: (i) => [
           "permissions",
@@ -18837,13 +19192,13 @@ var init_server = __esm({
         name: "tendril_doctor",
         annotations: { readOnlyHint: true },
         description: "Machine readiness + version status in one shot: installed vs latest version (with publish date and update remediation), browser identity, font-cache state, Figma desktop MCP reachability, and whether this machine holds a LIVE portal session (checked against the portal itself; informational \u2014 publishing needs it, verification never does; when absent, offer tendril_login). Use to self-diagnose before recording/scoring, or whenever versions are in question. Exit 1 = something not ready; the report says exactly what and how to fix it.",
-        schema: z15.object({}),
+        schema: z16.object({}),
         argv: () => ["doctor"]
       },
       {
         name: "tendril_login",
         description: "Connect this machine to the user's Tendril portal account WITHOUT the user touching a terminal \u2014 phase one of the browser-approve sign-in. Starts the handshake, opens their browser to the approve page, and returns a verification link plus a short code. RELAY BOTH to the user verbatim: they click Approve on the page, and they must check the page shows EXACTLY this code (that check is the phishing defence \u2014 an attacker can send someone else's approve link). Then call tendril_login_wait to finish. Offer this whenever tendril_doctor reports no portal session and the user wants to publish or share; publishing needs it, verification never does.",
-        schema: z15.object({
+        schema: z16.object({
           portal: optStr("portal origin override for self-hosted portals (defaults to https://app.trytendril.com)")
         }),
         argv: (i) => ["login", "--device-start", ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []]
@@ -18851,13 +19206,13 @@ var init_server = __esm({
       {
         name: "tendril_login_wait",
         description: "Phase two of the browser-approve sign-in: waits (up to ten minutes, with live progress) for the user to click Approve on the page tendril_login opened, then stores the session on this machine. Call it right after relaying the link and code. A denial, a lapse, and success each come back as their own sentence; confirm the result to the user, and on success they are ready to publish.",
-        schema: z15.object({}),
+        schema: z16.object({}),
         argv: () => ["login", "--device-wait"]
       },
       {
         name: "tendril_figma_connect",
         description: "Grant this machine read access to the user's Figma files over Figma's API \u2014 phase one of the browser Figma connection. Recording over the Figma MCP transport pays a hard per-day call quota; this connection lets recording fetch over Figma's REST API instead (per-minute, batched), so large component sets stop hitting daily limits. Starts the handshake and returns a connect link \u2014 RELAY IT to the user verbatim: they sign in to their portal account if asked, then click Allow on Figma's consent screen (read-only file access; revocable any time in their Figma settings). Then call tendril_figma_connect_wait to finish. You cannot consent for them: the portal only accepts the browser's signed-in click, never this machine's token. Offer it when a recording plan warns about Figma call limits; requires a portal session (tendril_login).",
-        schema: z15.object({
+        schema: z16.object({
           portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)")
         }),
         argv: (i) => ["figma-connect", "--start", ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []]
@@ -18865,13 +19220,13 @@ var init_server = __esm({
       {
         name: "tendril_figma_connect_wait",
         description: "Phase two of the browser Figma connection: waits (with live progress) for the user's Allow click on Figma's consent screen, then stores the credential on this machine (it renews itself from then on). Call it right after relaying the connect link. A decline, a lapse, and success each come back as their own sentence \u2014 report the outcome to the user.",
-        schema: z15.object({}),
+        schema: z16.object({}),
         argv: () => ["figma-connect", "--wait"]
       },
       {
         name: "tendril_publish",
         description: "Publish a VERIFIED bundle to the user's portal \u2014 phase one of the browser-approved publish. Re-publishing an already-published component completes in one call. A component's FIRST publish is a human-only decision the portal enforces: this call requests the approval and returns the approve-page link \u2014 RELAY IT to the user verbatim, along with which account the result says to be signed in as (they click Approve in the browser; approving includes accepting the design system's publishing terms, which is their decision to make, never yours to urge). Then call tendril_publish_wait to finish. You cannot approve this yourself: the portal only accepts the decision from their signed-in browser, never from this machine's token. Requires a green verify (the CLI refuses a declined run) and a portal session (tendril_login).",
-        schema: z15.object({
+        schema: z16.object({
           bundleDir: str("bundle directory (verified \u2014 carries component.json and verify-evidence)"),
           portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)")
         }),
@@ -18880,38 +19235,55 @@ var init_server = __esm({
       {
         name: "tendril_publish_wait",
         description: 'Phase two of the browser-approved publish. Waits in a BOUNDED window (~1 minute per call) for the user\'s Approve click on the page tendril_publish returned, then uploads the bundle, commits it, and returns the live publication URL. Call it right after relaying the approve link. While the human has not decided, each call returns `status: "approval-pending"` \u2014 that is a heartbeat, not a failure: tell the user in one short line that you are still waiting (restate the approve link and the account to approve as, ONLY if they seem lost; never urge the decision), then call this again to keep waiting. The request stays live for ~30 minutes. A denial, a lapse, and success each come back as their own sentence \u2014 report the outcome, and on success lead with the live URL. A decided approval continues straight into upload and commit INSIDE the same call \u2014 that phase can take minutes and may render no progress in some hosts; that is normal, not stuck. Some hosts render no progress at all during a call; the bounded window IS the liveness, so never describe an in-flight call as stuck \u2014 and a brief liveness line roughly every few minutes is enough, you need not narrate every heartbeat (each pending return carries waitedTotalSeconds/remainingSeconds to say where the wait stands).',
-        schema: z15.object({
+        schema: z16.object({
           bundleDir: str("the same bundle directory tendril_publish was called with"),
           portal: optStr("portal origin override (must match tendril_publish's)")
         }),
         argv: (i) => ["publish", i["bundleDir"], "--approve-wait", "--wait-window", "55", ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []]
       },
+      {
+        name: "tendril_pull",
+        description: "Bring a published component's RECORDING SET onto this machine \u2014 the recorded design truth its verdict was measured against. Use it when the recordings are not here: a fresh machine, a clone with no recordings/ directory, or a component someone else on the team published. ONE bounded call, no wait twin. Needs a portal session (tendril_login) because a recording set belongs to the account that published it; everything afterwards \u2014 verify, compose, republish \u2014 is local, offline and account-less as always. The name is EXACT and the portal's refusals list the user's real component names, so a name that does not resolve is a one-step correction rather than a dead end; when one name spans two design systems, pass `figmaFile`. It writes to ./recordings/<component>/ and never overwrites a different set already there. AFTER pulling, call tendril_record_status on each set you pulled, then continue the connect prompt from its step 3.",
+        schema: z16.object({
+          component: str("the component name, exactly as the user's library shows it"),
+          figmaFile: optStr("the design system's Figma file key \u2014 only when one name spans several of the user's design systems (the portal's refusal says when)"),
+          dest: optStr("where the set lands (default: ./recordings/<component>)"),
+          portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)")
+        }),
+        argv: (i) => [
+          "pull",
+          i["component"],
+          ...typeof i["figmaFile"] === "string" ? ["--figma-file", i["figmaFile"]] : [],
+          ...typeof i["dest"] === "string" ? ["--dest", i["dest"]] : [],
+          ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []
+        ]
+      },
       {
         name: "tendril_record_next",
         annotations: { readOnlyHint: true },
         description: "Get the next pending recording instruction (which Figma MCP tool to call for which node, and how to save it). RARELY NEEDED: every ingest/fetch response already carries `next` \u2014 use this only to resume an interrupted session. The full queue is known from plan, so independent reps may be recorded in any order (and in parallel).",
-        schema: z15.object({ setDir: str("recording set directory") }),
+        schema: z16.object({ setDir: str("recording set directory") }),
         argv: (i) => ["record", "next", "--set", i["setDir"]]
       },
       {
         name: "tendril_record_rest_fetch",
         description: "Fetch a recording set's pixels+geometry over Figma's REST API \u2014 the step `record next` names as rest_fetch when the set's REST channel is active. The CLI makes these requests itself with the user's connected Figma credential (tendril_figma_connect); you make NO Figma call for it and none can substitute. It first self-checks one or two probe poses against their MCP-recorded references (zero-pixel tolerance) and falls the whole set back to MCP recording if the transports disagree; then it bulk-fetches the rest, batched and paced, spending no MCP quota. Requires the probe poses to be recorded first \u2014 record next tells you when.",
-        schema: z15.object({ setDir: str("recording set directory") }),
+        schema: z16.object({ setDir: str("recording set directory") }),
         argv: (i) => ["record", "rest-fetch", "--set", i["setDir"]]
       },
       {
         name: "tendril_record_bindings",
         description: "Fetch Figma's instance\u2192component bindings for an EXISTING MCP-recorded set \u2014 one or two batched REST calls, no re-recording, pixels/geometry/identity untouched. This is how components that are ALREADY recorded and generated become connectable: the bindings make cross-component pairing id-backed, so `tendril compose` can propose it for the human's confirm. Every binding is congruence-verified against the recorded metadata (a design that changed since recording refuses per pose, named). The CLI makes the requests itself with the user's connected Figma credential (tendril_figma_connect); you make NO Figma call. The result names the next step \u2014 including when no partner set is visible in the scanned root (co-locate the sets or pass compose --library). For sets recorded before file identity was captured, pass the design's file key as `file`.",
-        schema: z15.object({ setDir: str("recording set directory"), file: optStr("the design's file key (figma.com/design/<KEY>/\u2026) \u2014 only for sets whose manifest lacks figmaFile; an operator assertion, congruence still gates every binding") }),
+        schema: z16.object({ setDir: str("recording set directory"), file: optStr("the design's file key (figma.com/design/<KEY>/\u2026) \u2014 only for sets whose manifest lacks figmaFile; an operator assertion, congruence still gates every binding") }),
         argv: (i) => ["record", "bindings", "--set", i["setDir"], ...typeof i["file"] === "string" ? ["--file", i["file"]] : []]
       },
       {
         name: "tendril_compose",
         description: "Put ONE composition pairing in front of the user's BROWSER \u2014 phase one of the browser-approved connect (invariant-5 migration; the terminal `--confirm-compositions` path remains for humans at a TTY). Requires a portal session (tendril_login \u2014 one browser Approve). Returns the approve-page link: RELAY IT verbatim, name the account the result says to approve as, and never urge the decision \u2014 the card carries the engine's honest disclosures and the human reads them. Deny on the card is NOT NOW (this request only, never a permanent decline). You cannot decide this yourself on any channel: the portal accepts the decision only from the user's signed-in browser, and the terminal flag only from an interactive TTY. A host with several open pairings needs `pair` (one card = one decision). Then finish with tendril_compose_wait. Both recording sets must be visible in one scanned workspace \u2014 co-locate them or pass `library`.",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("the HOST recording set directory (the component that embeds the partner)"),
           pair: optStr("the pair-key to request when the host has several open pairings"),
-          library: z15.array(z15.string()).optional().describe("workspace root(s) holding the partner recording set(s) \u2014 required when they live in another project root"),
+          library: z16.array(z16.string()).optional().describe("workspace root(s) holding the partner recording set(s) \u2014 required when they live in another project root"),
           portal: optStr("portal origin override (defaults to the stored session's portal)")
         }),
         argv: (i) => [
@@ -18927,7 +19299,7 @@ var init_server = __esm({
       {
         name: "tendril_compose_wait",
         description: 'Phase two of the browser-approved connect. Waits in a BOUNDED window (~1 minute per call) for the user\'s decision on the card tendril_compose returned; on Approve it records the SAME manifest entry the terminal confirm writes \u2014 after re-deriving the pairing from the CURRENT recordings and refusing if anything changed underneath the click (the click is then not wrong; the project moved \u2014 run the connect again). While undecided, each call returns `status: "approval-pending"` \u2014 a heartbeat, not a failure: one short liveness line to the user, then call again; the request stays live ~30 minutes, and a decided card can take moments to land. NOT NOW, a lapse, and success each arrive as their own sentence \u2014 report the one you got. After success: regenerate the HOST bundle with the same library roots (brief \u2192 generate \u2192 score \u2192 verify), then republish \u2014 announce the republish in one line first. Compose waits follow the same heartbeat contract as publish waits: never urge, never call an in-flight wait stuck.',
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("the same HOST set directory tendril_compose was called with"),
           portal: optStr("portal origin override (must match tendril_compose's)")
         }),
@@ -18936,10 +19308,10 @@ var init_server = __esm({
       {
         name: "tendril_record_fetch",
         description: "Download a Figma asset URL (from get_screenshot's image_url) straight to disk and ingest it as the rep's envelope \u2014 the fallback when only the screenshot piece needs (re-)recording; for a rep's standard three recordings PREFER tendril_record_ingest_rep. Never download the image yourself: the bytes must not pass through your context.",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug"),
-          tool: z15.enum(["get_screenshot"]).describe("get_screenshot"),
+          tool: z16.enum(["get_screenshot"]).describe("get_screenshot"),
           url: str("image_url from the Figma response, verbatim")
         }),
         argv: (i) => ["record", "fetch", "--set", i["setDir"], "--rep", i["rep"], "--tool", i["tool"], "--url", i["url"]]
@@ -18947,15 +19319,15 @@ var init_server = __esm({
       {
         name: "tendril_record_ingest_rep",
         description: "Ingest a rep's ENTIRE recording in ONE call \u2014 the get_metadata response, the get_design_context response, and the get_screenshot image_url together. Make the three Figma calls first, in protocol order (get_metadata, then get_design_context with excludeScreenshot=true, then get_screenshot with contentsOnly=true and maxDimension=4096 \u2014 isolation keeps the editor's component-set chrome out of the padded export, where it would otherwise score as unpaintable reference ink), then pass all three here VERBATIM. PREFER THIS over three separate ingest/fetch calls: one approvable operation per rep instead of three. Pieces land independently: on a partial failure the error names exactly which piece(s) to re-record \u2014 the rest are already on disk. The response carries `next` and, for design context, `assets` (auto-fetched server-side; only listed failures need record_asset).",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug"),
           // Parts arrays FIRST: in the field, EVERY real Figma response is
           // multi-block (run 6: 49/49 reps — metadata 2 blocks, design
           // context 5-6), so the arrays are the norm and the single-string
           // params the rare case, not the reverse.
-          metadataParts: z15.array(z15.string()).optional().describe("get_metadata response blocks, every block in order, each verbatim \u2014 never hand-join blocks yourself. Multi-block responses are common (run 6: 49/49 reps); a single block wrapped in a one-element array is equally fine."),
-          contextParts: z15.array(z15.string()).optional().describe("get_design_context response blocks, every block in order, each verbatim \u2014 the NORMAL param (real responses arrive as 5-6 blocks)"),
+          metadataParts: z16.array(z16.string()).optional().describe("get_metadata response blocks, every block in order, each verbatim \u2014 never hand-join blocks yourself. Multi-block responses are common (run 6: 49/49 reps); a single block wrapped in a one-element array is equally fine."),
+          contextParts: z16.array(z16.string()).optional().describe("get_design_context response blocks, every block in order, each verbatim \u2014 the NORMAL param (real responses arrive as 5-6 blocks)"),
           screenshotUrl: optStr("image_url from the get_screenshot response, verbatim \u2014 the CLI downloads it; the bytes never pass through your context"),
           metadata: optStr("ONLY when get_metadata genuinely returned one single block: its text verbatim (otherwise use metadataParts)"),
           context: optStr("ONLY when get_design_context genuinely returned one single block: its text verbatim (otherwise use contextParts)")
@@ -18988,7 +19360,7 @@ var init_server = __esm({
       {
         name: "tendril_record_ingest",
         description: "Single-piece ingest of a VERBATIM Figma tool-response \u2014 the fallback path (re-recording one failed piece, the set-level get_variable_defs and get_motion_context steps, get_metadata_interior for mains); for a rep's standard three recordings PREFER tendril_record_ingest_rep, which takes them all in one call. Pass `text` (single block) or `texts` (response split into multiple output blocks \u2014 each block verbatim, in order; NEVER hand-join them): the CLI constructs the envelope from the same bytes. The response includes `next` and, for get_design_context, `assets` (auto-fetched; only listed failures need manual handling).",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug, or __set__ for the set-level steps (get_variable_defs, get_motion_context)"),
           // Enumerated, not a free string: this value reaches a file path.
@@ -19001,9 +19373,9 @@ var init_server = __esm({
           // dead-ended every MCP-driven recording at the motion step with
           // no MCP path to complete (the CLI accepted what the primary
           // surface could not send). The pin lives in server.test.ts.
-          tool: z15.enum(["get_design_context", "get_metadata", "get_screenshot", "get_variable_defs", "get_metadata_interior", "get_motion_context"]),
+          tool: z16.enum(["get_design_context", "get_metadata", "get_screenshot", "get_variable_defs", "get_metadata_interior", "get_motion_context"]),
           text: optStr("the tool response text VERBATIM \u2014 exactly as returned, unmodified (single-block responses; text tools only \u2014 screenshots go through record_fetch)"),
-          texts: z15.array(z15.string()).optional().describe("when the response arrived as MULTIPLE output blocks: every block, in order, each verbatim \u2014 never hand-join blocks yourself"),
+          texts: z16.array(z16.string()).optional().describe("when the response arrived as MULTIPLE output blocks: every block, in order, each verbatim \u2014 never hand-join blocks yourself"),
           file: optStr("path to a saved envelope JSON (alternative to text/texts)")
         }),
         // The text rides a temp file, never argv: Windows caps a command
@@ -19027,7 +19399,7 @@ var init_server = __esm({
       {
         name: "tendril_record_asset",
         description: "FALLBACK ONLY \u2014 ingest auto-fetches design-context assets; use this just for assets listed in an ingest response's `assets.failed`. Batch mode: pass `dir` to ingest every asset-*.<ext> in a directory in ONE call. SVGs with active content are rejected; sizes are capped.",
-        schema: z15.object({
+        schema: z16.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug"),
           name: optStr("asset-<id>.<ext> (single-asset mode)"),
@@ -19048,13 +19420,13 @@ var init_server = __esm({
         name: "tendril_record_status",
         annotations: { readOnlyHint: true },
         description: "Recording-set completeness: per-rep recorded/missing tools, files that exist but are unusable (invalid \u2014 re-record those), and whether the set-level steps are recorded (get_variable_defs always; get_motion_context when the plan asked \u2014 ADR-016). `complete` means the RECORDING is usable by the next pipeline step \u2014 it does NOT mean nothing is left to decide: read the `composition` field too (always present: openPairs lists unconfirmed partner pairs with pair-keys \u2014 surface those to the user BEFORE generating the host, partner-first; {unavailable} means discovery could not run, which is unknown, not 'no pairs').",
-        schema: z15.object({ setDir: str("recording set directory") }),
+        schema: z16.object({ setDir: str("recording set directory") }),
         argv: (i) => ["record", "status", "--set", i["setDir"]]
       },
       {
         name: "tendril_engine_brief",
         description: "AGENT-HARNESS engine, step 1: emits the task payload file (system brief + every recorded config's emission, box, assets, tokens) and the protocol. YOU (the calling agent) implement the bundle; the CLI is the only judge. Read the payload file completely before proposing.",
-        schema: z15.object({
+        schema: z16.object({
           taskOrSet: str("a recording-set directory (from tendril_record), or a reference task name \u2014 an unknown name returns the valid list in the error"),
           // Required by design, not convenience: the model choice must be
           // settled BEFORE generation starts. A smoke run picked its own
@@ -19081,13 +19453,13 @@ var init_server = __esm({
       {
         name: "tendril_engine_score",
         description: "AGENT-HARNESS engine, step 2 (the oracle): scores a candidate bundle directory against recorded truth \u2014 per-config pixels, behaviors, state parity (recording-selected \u2014 a bundle cannot unschedule it) \u2014 and returns feedback plus evidence artifacts. Iterate until allPass or two non-improving rounds. Only THIS tool's output counts as a score; never claim numbers yourself. allPass ends the LOOP, not the run: finish with tendril_verify, and a green verify's terminal step is publishing \u2014 the component is done when it is LIVE, not when it scores.",
-        schema: z15.object({
+        schema: z16.object({
           taskOrSet: str("reference task name or recording-set directory"),
           candidateDir: str("directory containing the proposed bundle files"),
           bar: optStr("pass (default) or cert"),
           host: optStr("your host identity (e.g. claude-code, cursor, codex) \u2014 recorded as self-reported provenance"),
           model: str("the model that proposed the candidate \u2014 REQUIRED; recorded as self-reported provenance, and the CLI refuses to score without it"),
-          rebind: z15.boolean().optional().describe("explicitly re-bind an already-bound bundle to a DIFFERENT recording set \u2014 scoring refuses this otherwise, because rebinding silently rewrites the bundle's verification identity; only pass after telling the user"),
+          rebind: z16.boolean().optional().describe("explicitly re-bind an already-bound bundle to a DIFFERENT recording set \u2014 scoring refuses this otherwise, because rebinding silently rewrites the bundle's verification identity; only pass after telling the user"),
           library: optStr("workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: the server's working directory) \u2014 pass the same root the brief used")
         }),
         argv: (i) => [
@@ -19106,7 +19478,7 @@ var init_server = __esm({
       {
         name: "tendril_codeconnect",
         description: "Emit a Figma Code Connect template (.figma.ts) for a certified bundle \u2014 every Figma variant value mapped to its verified prop fragment from recorded truth, stamped with the bundle's trust statement. EXTRA VALUE step after verify passes: offer it to the user. Publishing is the USER'S action (their Figma token, Organization/Enterprise plan) \u2014 via npx @figma/code-connect connect publish, or the Figma MCP's own add_code_connect_map/send_code_connect_mappings tools if available in this session.",
-        schema: z15.object({
+        schema: z16.object({
           bundleDir: str("bundle directory (carries component.json)"),
           figmaUrl: str("figma.com /design/ URL of the COMPONENT SET, with node-id (ask the user to Copy link to selection if you don't have it)"),
           set: optStr("recording set override (default: the bundle's provenance path)"),
@@ -19124,7 +19496,7 @@ var init_server = __esm({
       {
         name: "tendril_verify",
         description: "Verify/check that a component matches its Figma design \u2014 use when the user asks whether an implementation is faithful to the design, or to re-certify an existing Tendril bundle. Recomputes full verification (per-config status, behaviors, composition, evidence artifacts). Free, account-less, network-less \u2014 the trust anchor. Exit 5 means below the target bar with an honest report \u2014 sub-bar scores, or at bar cert a config demoted by absent-ink clusters. A GREEN run writes the inspect sheet itself and returns `next`: its terminal step is publishing (tendril_publish \u2192 tendril_publish_wait) \u2014 a verified component reachable only on local disk is an unfinished run; a sub-bar run never publishes.",
-        schema: z15.object({
+        schema: z16.object({
           bundleDir: str("bundle directory to verify"),
           bar: optStr("pass (default) or cert"),
           set: optStr("recording-set directory override"),
@@ -19141,12 +19513,12 @@ var init_server = __esm({
       {
         name: "tendril_generate_curated",
         description: "CURATED engine (explicit alternative path): generation by an allowlisted API model over the user's OpenRouter-compatible key, with cost consent, hard spend caps, and resume. Use ONLY when the user asks for API-model generation instead of implementing it yourself.",
-        schema: z15.object({
+        schema: z16.object({
           input: str("reference task name or recording-set directory"),
           model: optStr("OpenRouter model id (default: allowlist pointer)"),
           bar: optStr("pass (default) or cert"),
           cap: optStr("spend cap in USD (default 1.50)"),
-          yes: z15.boolean().optional().describe("accept the cost consent (the user must have approved the spend)")
+          yes: z16.boolean().optional().describe("accept the cost consent (the user must have approved the spend)")
         }),
         argv: (i) => [
           "generate",
@@ -19411,6 +19783,57 @@ var init_permissions = __esm({
   }
 });
 
+// packages/cli/src/commands/publish-recordings.ts
+import { existsSync as existsSync45, readFileSync as readFileSync41, readdirSync as readdirSync18, statSync as statSync6 } from "node:fs";
+import path55 from "node:path";
+import { createHash as createHash13 } from "node:crypto";
+function sha256Sync(chunks) {
+  const h = createHash13("sha256");
+  for (const chunk of chunks) h.update(chunk);
+  return h.digest("hex");
+}
+function planRecordingCarry(input) {
+  const chosen = input.override ?? input.provenancePath;
+  const setDir = path55.resolve(input.cwd, chosen);
+  const named = input.override === void 0 ? "the recording set this bundle names" : "the recording set you named";
+  const without = (why) => ({
+    carried: false,
+    note: `publishing without the recording set: ${why} (looked in ${setDir})`
+  });
+  if (!existsSync45(setDir)) return without(`${named} is not on this machine`);
+  try {
+    if (!statSync6(setDir).isDirectory()) return without(`${named} is not a directory`);
+  } catch (error) {
+    return without(`${named} could not be read (${error.message})`);
+  }
+  let packed;
+  try {
+    packed = packRecordingArchive(
+      {
+        exists: (relPath) => existsSync45(path55.join(setDir, relPath)),
+        read: (relPath) => new Uint8Array(readFileSync41(path55.join(setDir, relPath))),
+        listRep: (rep) => existsSync45(path55.join(setDir, rep)) ? readdirSync18(path55.join(setDir, rep)) : []
+      },
+      { sha256: sha256Sync }
+    );
+  } catch (error) {
+    return without(`${named} could not be packed (${error.message})`);
+  }
+  if (!packed.ok) return without(packed.refusal);
+  if (packed.setHash !== input.scoredSetHash) {
+    return without(
+      `${named} is not the one this verdict was measured against (the set here derives ${packed.setHash.slice(0, 12)}\u2026, the report was scored on ${input.scoredSetHash.slice(0, 12)}\u2026)`
+    );
+  }
+  return { carried: true, envelopeText: packed.envelopeText, setHash: packed.setHash, setDir, staleEnrichment: packed.staleEnrichment };
+}
+var init_publish_recordings = __esm({
+  "packages/cli/src/commands/publish-recordings.ts"() {
+    "use strict";
+    init_src4();
+  }
+});
+
 // packages/cli/src/commands/publish.ts
 var publish_exports = {};
 __export(publish_exports, {
@@ -19419,8 +19842,8 @@ __export(publish_exports, {
   runPublish: () => runPublish,
   spendPendingApproval: () => spendPendingApproval
 });
-import { existsSync as existsSync45, readFileSync as readFileSync41, rmSync as rmSync8, writeFileSync as writeFileSync23 } from "node:fs";
-import path55 from "node:path";
+import { existsSync as existsSync46, readFileSync as readFileSync42, rmSync as rmSync8, writeFileSync as writeFileSync23 } from "node:fs";
+import path56 from "node:path";
 async function runPublish(opts) {
   if (opts.waitWindowSeconds !== void 0 && opts.approveWait !== true) {
     fail(opts, ExitCode.InputValidation, {
@@ -19436,7 +19859,7 @@ async function runPublish(opts) {
       remediation: "Pass e.g. --wait-window 55."
     });
   }
-  const bundleDir = path55.resolve(opts.bundleDir);
+  const bundleDir = path56.resolve(opts.bundleDir);
   const bundle = readBundle(opts, bundleDir);
   const report = bundle.report;
   if (typeof report["rulerExit"] !== "number" || !Number.isInteger(report["rulerExit"])) {
@@ -19481,7 +19904,7 @@ async function runPublish(opts) {
   const sheetEntry = surface.published.find((p) => p.role === "inspect-sheet");
   if (sheetEntry !== void 0) {
     const missingCrops = missingInspectCrops(
-      readFileSync41(path55.join(bundleDir, sheetEntry.path), "utf8"),
+      readFileSync42(path56.join(bundleDir, sheetEntry.path), "utf8"),
       surface.published.map((p) => p.path)
     );
     if (missingCrops.length > 0) {
@@ -19583,8 +20006,8 @@ async function runPublish(opts) {
   if (opts.approveWait === true) spendPendingApproval();
   const uploaded = [];
   for (const object of opened.value.plan.objects) {
-    const file = path55.join(bundleDir, object.relPath);
-    if (!existsSync45(file)) {
+    const file = path56.join(bundleDir, object.relPath);
+    if (!existsSync46(file)) {
       fail(opts, ExitCode.InputValidation, {
         error: `the portal expects ${object.relPath}, and it is not in ${opts.bundleDir}`,
         code: "planned-file-missing",
@@ -19594,12 +20017,49 @@ async function runPublish(opts) {
     const sent = await client.upload({
       publicationId: opened.value.publicationId,
       relPath: object.relPath,
-      bytes: new Uint8Array(readFileSync41(file))
+      bytes: new Uint8Array(readFileSync42(file))
     });
     if (!sent.ok) refuse(opts, sent, "upload-refused", true);
     uploaded.push({ relPath: object.relPath, deduplicated: sent.value.deduplicated });
     emitProgress(uploaded.length, opened.value.plan.objects.length, `uploading ${object.relPath}`);
   }
+  let recordingNote;
+  let carried;
+  if (opts.noRecordings === true) {
+  } else if (client.carryRecordings === void 0) {
+    recordingNote = "publishing without the recording set: this client cannot carry recordings";
+  } else {
+    const plan = planRecordingCarry({
+      bundleDir,
+      cwd: process.cwd(),
+      ...opts.recordings === void 0 ? {} : { override: opts.recordings },
+      provenancePath: bundle.manifest.provenance.recordingSet.path,
+      scoredSetHash: scoredRecordingSetHash(report)
+    });
+    if (!plan.carried) {
+      recordingNote = plan.note;
+    } else {
+      emitProgress(uploaded.length, uploaded.length, "carrying the recording set");
+      let sent;
+      try {
+        sent = await client.carryRecordings({ publicationId: opened.value.publicationId, envelopeText: plan.envelopeText });
+      } catch (error) {
+        sent = { ok: false, status: 0, refusal: `the recording set could not be sent (${error.message})` };
+      }
+      if (sent.ok) {
+        carried = { setHash: plan.setHash, setDir: plan.setDir, sizeBytes: plan.envelopeText.length, staleEnrichment: plan.staleEnrichment };
+      } else if (sent.alreadyCarried === true) {
+        carried = { setHash: sent.setHash ?? plan.setHash, setDir: plan.setDir, sizeBytes: plan.envelopeText.length, staleEnrichment: plan.staleEnrichment };
+        recordingNote = "this publication already carried its recording set from an earlier attempt, and that copy stands \u2014 the set on this machine has since changed outside the scored hash (a `record bindings` re-run does this), which changes nothing about the verdict";
+      } else {
+        recordingNote = sent.status === 404 ? "publishing without the recording set: this portal does not carry recording sets yet \u2014 the component published normally" : `publishing without the recording set: ${sent.refusal}`;
+        recordingNote += ` (the set here is ${plan.setDir}, ${plan.setHash.slice(0, 12)}\u2026)`;
+        if (sent.needsConfirmation?.approvePath !== void 0) {
+          recordingNote += ` \u2014 approve it once at ${origin}${sent.needsConfirmation.approvePath}, then publish again`;
+        }
+      }
+    }
+  }
   emitProgress(uploaded.length, uploaded.length, "upload complete \u2014 committing the publication");
   const committed = await client.commit({ publicationId: opened.value.publicationId });
   if (committed.ok) {
@@ -19624,7 +20084,15 @@ async function runPublish(opts) {
       figmaFile: opened.value.figmaFile,
       rulerVersion: opened.value.rulerVersion,
       resumed: opened.value.resumed === true,
-      files: uploaded
+      files: uploaded,
+      recordings: carried === void 0 ? { carried: false, ...recordingNote === void 0 ? {} : { note: recordingNote } } : {
+        carried: true,
+        setHash: carried.setHash,
+        setDir: carried.setDir,
+        sizeBytes: carried.sizeBytes,
+        staleEnrichment: carried.staleEnrichment,
+        ...recordingNote === void 0 ? {} : { note: recordingNote }
+      }
     },
     () => {
       const reused = uploaded.filter((u) => u.deduplicated).length;
@@ -19637,27 +20105,42 @@ async function runPublish(opts) {
 `);
       process.stdout.write(`  verdict as scored by ruler ${opened.value.rulerVersion}
 `);
+      if (carried !== void 0) {
+        process.stdout.write(`  recording set carried \u2014 pull it on another machine with \`${tendrilCommand(`pull ${JSON.stringify(componentName)}`)}\`
+`);
+        if (recordingNote !== void 0) process.stdout.write(`  ${recordingNote}
+`);
+        if (carried.staleEnrichment.length > 0) {
+          process.stdout.write(
+            `  left ${String(carried.staleEnrichment.length)} stale binding record(s) behind (${carried.staleEnrichment.slice(0, 3).join(", ")}) \u2014 re-run \`${tendrilCommand("record bindings")}\` after pulling
+`
+          );
+        }
+      } else if (recordingNote !== void 0) {
+        process.stdout.write(`  ${recordingNote}
+`);
+      }
     }
   );
 }
 function readBundle(opts, bundleDir) {
-  const manifestPath2 = path55.join(bundleDir, "component.json");
-  const reportPath = path55.join(bundleDir, EVIDENCE_DIR, VERIFY_REPORT_FILENAME);
-  if (!existsSync45(manifestPath2)) {
+  const manifestPath2 = path56.join(bundleDir, "component.json");
+  const reportPath = path56.join(bundleDir, EVIDENCE_DIR, VERIFY_REPORT_FILENAME);
+  if (!existsSync46(manifestPath2)) {
     fail(opts, ExitCode.InputValidation, {
       error: `there is no component.json in ${opts.bundleDir}, so this is not a bundle`,
       code: "not-a-bundle",
       remediation: `Point publish at a directory a Tendril run produced. \`${tendrilCommand("generate --help")}\` shows how one is made.`
     });
   }
-  if (!existsSync45(reportPath)) {
+  if (!existsSync46(reportPath)) {
     fail(opts, ExitCode.InputValidation, {
       error: `this bundle has never been verified \u2014 there is no ${EVIDENCE_DIR}/${VERIFY_REPORT_FILENAME}`,
       code: "bundle-not-verified",
       remediation: `Run \`${tendrilCommand(`verify ${opts.bundleDir}`)}\` first. Verification is free and needs no account; publishing without it would put a page up with no verdict on it.`
     });
   }
-  const { manifest } = readBundleManifest(readFileSync41(manifestPath2, "utf8"));
+  const { manifest } = readBundleManifest(readFileSync42(manifestPath2, "utf8"));
   if (manifest === void 0) {
     fail(opts, ExitCode.InputValidation, {
       error: "component.json did not parse as a bundle manifest",
@@ -19665,7 +20148,7 @@ function readBundle(opts, bundleDir) {
       remediation: `Re-emit the bundle \u2014 \`${tendrilCommand(`verify ${opts.bundleDir}`)}\` rewrites component.json \u2014 then publish.`
     });
   }
-  const reportText = readFileSync41(reportPath, "utf8");
+  const reportText = readFileSync42(reportPath, "utf8");
   let report;
   try {
     report = JSON.parse(reportText);
@@ -19733,7 +20216,7 @@ function refuse(opts, sent, code, rejoins = false) {
   });
 }
 function pendingApprovalPath() {
-  return path55.join(path55.dirname(sessionPath()), "pending-publish.json");
+  return path56.join(path56.dirname(sessionPath()), "pending-publish.json");
 }
 async function runApprovalFlow(opts, client, bundleDir, input) {
   const requested = await client.requestApproval({ componentName: input.componentName, figmaFile: input.figmaFile });
@@ -19780,9 +20263,9 @@ async function runApprovalFlow(opts, client, bundleDir, input) {
 async function approveWaitPhase(opts, client, bundleDir, subject) {
   const file = pendingApprovalPath();
   let pending;
-  if (existsSync45(file)) {
+  if (existsSync46(file)) {
     try {
-      const parsed = JSON.parse(readFileSync41(file, "utf8"));
+      const parsed = JSON.parse(readFileSync42(file, "utf8"));
       if (typeof parsed.approvalId === "string" && typeof parsed.approveUrl === "string" && typeof parsed.expiresAt === "string") {
         pending = { pollSeconds: 3, bundleDir, ...parsed };
       }
@@ -19871,6 +20354,7 @@ var init_publish = __esm({
     init_src4();
     init_invocation();
     init_output();
+    init_publish_recordings();
     init_publish_client();
     init_run_presence();
     APPROVAL_WAIT_CAP_MS = 31 * 6e4;
@@ -19886,9 +20370,9 @@ __export(compose_approve_exports, {
   runComposeApproveStart: () => runComposeApproveStart,
   runComposeApproveWait: () => runComposeApproveWait
 });
-import { createHash as createHash13 } from "node:crypto";
-import { existsSync as existsSync46, mkdirSync as mkdirSync14, readFileSync as readFileSync42, rmSync as rmSync9, writeFileSync as writeFileSync24 } from "node:fs";
-import path56 from "node:path";
+import { createHash as createHash14 } from "node:crypto";
+import { existsSync as existsSync47, mkdirSync as mkdirSync14, readFileSync as readFileSync43, rmSync as rmSync9, writeFileSync as writeFileSync24 } from "node:fs";
+import path57 from "node:path";
 function composeSubjectDigest(subject) {
   const preimage = JSON.stringify([
     subject.hostComponent,
@@ -19899,16 +20383,16 @@ function composeSubjectDigest(subject) {
     subject.instances.map((i) => [i.hostRep, i.instanceId, i.poseVariantNodeId]),
     subject.disclosures
   ]);
-  return createHash13("sha256").update(preimage, "utf8").digest("hex");
+  return createHash14("sha256").update(preimage, "utf8").digest("hex");
 }
 function composeSubjectFor(hostSet, pair) {
   const manifest = loadManifest(hostSet);
   const canonical = {
     hostComponent: manifest.component,
     hostFigmaFile: manifest.figmaFile ?? "unidentified",
-    hostManifestSha256: createHash13("sha256").update(readFileSync42(path56.join(hostSet, "recording-set.json"))).digest("hex"),
+    hostManifestSha256: createHash14("sha256").update(readFileSync43(path57.join(hostSet, "recording-set.json"))).digest("hex"),
     pairKey: pair.key,
-    partnerManifestSha256: pair.partnerDirs.map((d) => [fromStoredRel(path56.relative(hostSet, d)), createHash13("sha256").update(readFileSync42(path56.join(d, "recording-set.json"))).digest("hex")]).sort((a, b) => a[0] < b[0] ? -1 : 1),
+    partnerManifestSha256: pair.partnerDirs.map((d) => [fromStoredRel(path57.relative(hostSet, d)), createHash14("sha256").update(readFileSync43(path57.join(d, "recording-set.json"))).digest("hex")]).sort((a, b) => a[0] < b[0] ? -1 : 1),
     instances: [...pair.instances].map((i) => ({ hostRep: i.hostRep, instanceId: i.instanceId, poseVariantNodeId: i.poseVariantNodeId })).sort((a, b) => a.hostRep + a.instanceId < b.hostRep + b.instanceId ? -1 : 1),
     disclosures: [...pair.disclosures]
   };
@@ -19961,10 +20445,10 @@ function composePortalClient(flags) {
   return new HttpPublishClient({ origin, token: found.token });
 }
 function pendingComposePath() {
-  return path56.join(path56.dirname(sessionPath()), "pending-compose.json");
+  return path57.join(path57.dirname(sessionPath()), "pending-compose.json");
 }
 function openPairsFor(hostSet, roots) {
-  const scanRoots = [.../* @__PURE__ */ new Set([...roots, path56.dirname(hostSet)])];
+  const scanRoots = [.../* @__PURE__ */ new Set([...roots, path57.dirname(hostSet)])];
   const edges = composeReport(buildComposeIndex(scanRoots));
   const pairs = substitutionPairs(edges, hostSet);
   const { raw } = readManifestFile(hostSet);
@@ -19975,7 +20459,7 @@ function openPairsFor(hostSet, roots) {
   return pairs.filter((p) => !decidedKeys.has(p.key));
 }
 async function runComposeApproveStart(flags, hostSet, roots) {
-  if (!existsSync46(path56.join(hostSet, "recording-set.json"))) {
+  if (!existsSync47(path57.join(hostSet, "recording-set.json"))) {
     fail(flags, ExitCode.InputValidation, { error: `no recording-set.json in ${hostSet}`, code: "no-recording-set", remediation: "Point --set at a recorded host set." });
   }
   const open = openPairsFor(hostSet, roots);
@@ -20030,7 +20514,7 @@ async function runComposeApproveStart(flags, hostSet, roots) {
     roots,
     requestedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  mkdirSync14(path56.dirname(pendingComposePath()), { recursive: true });
+  mkdirSync14(path57.dirname(pendingComposePath()), { recursive: true });
   writeFileSync24(pendingComposePath(), `${JSON.stringify(pending, null, 2)}
 `, { mode: 384 });
   emitData(
@@ -20058,9 +20542,9 @@ async function runComposeApproveStart(flags, hostSet, roots) {
 async function runComposeApproveWait(flags, hostSet) {
   const file = pendingComposePath();
   let pending;
-  if (existsSync46(file)) {
+  if (existsSync47(file)) {
     try {
-      const parsed = JSON.parse(readFileSync42(file, "utf8"));
+      const parsed = JSON.parse(readFileSync43(file, "utf8"));
       if (typeof parsed.approvalId === "string" && typeof parsed.subjectDigest === "string" && typeof parsed.hostSet === "string" && typeof parsed.pairKey === "string") {
         pending = parsed;
       }
@@ -20074,7 +20558,7 @@ async function runComposeApproveWait(flags, hostSet) {
       remediation: `Start one first: ${tendrilCommand(`compose --set ${quoteArg(hostSet)} --approve-start`)} (the tendril_compose tool).`
     });
   }
-  if (path56.resolve(pending.hostSet) !== path56.resolve(hostSet)) {
+  if (path57.resolve(pending.hostSet) !== path57.resolve(hostSet)) {
     fail(flags, ExitCode.InputValidation, {
       error: `the waiting approval is for ${pending.hostSet}, and this wait is for ${hostSet}`,
       code: "pending-compose-mismatch",
@@ -20206,7 +20690,7 @@ async function runComposeApproveWait(flags, hostSet) {
 }
 async function runComposeApprove(flags) {
   const base = process.env["INIT_CWD"] ?? process.cwd();
-  const roots = flags.library !== void 0 && flags.library.length > 0 ? flags.library.map((d) => path56.resolve(base, d)) : [base];
+  const roots = flags.library !== void 0 && flags.library.length > 0 ? flags.library.map((d) => path57.resolve(base, d)) : [base];
   if (flags.set === void 0) {
     fail(flags, ExitCode.InputValidation, {
       error: "a compose decision flag requires --set <host> \u2014 a decision needs the host set it decides for",
@@ -20228,7 +20712,7 @@ async function runComposeApprove(flags) {
       remediation: "Pass e.g. --wait-window 55."
     });
   }
-  const hostSet = path56.resolve(base, flags.set);
+  const hostSet = path57.resolve(base, flags.set);
   if (flags.approveStart === true) {
     await runComposeApproveStart(flags, hostSet, roots);
     return;
@@ -20259,8 +20743,8 @@ __export(login_exports, {
   runLogout: () => runLogout
 });
 import { spawn } from "node:child_process";
-import { existsSync as existsSync47, mkdirSync as mkdirSync15, readFileSync as readFileSync43, rmSync as rmSync10, writeFileSync as writeFileSync25 } from "node:fs";
-import path57 from "node:path";
+import { existsSync as existsSync48, mkdirSync as mkdirSync15, readFileSync as readFileSync44, rmSync as rmSync10, writeFileSync as writeFileSync25 } from "node:fs";
+import path58 from "node:path";
 import { isCancel as isCancel3, password as password2 } from "@clack/prompts";
 async function runLogin(opts, deps) {
   const origin = (opts.to ?? process.env["TENDRIL_PORTAL_URL"] ?? DEFAULT_PORTAL_ORIGIN).replace(/\/+$/, "");
@@ -20354,12 +20838,12 @@ function settleDecision(opts, origin, outcome) {
   }
 }
 function pendingLoginPath() {
-  return path57.join(path57.dirname(sessionPath()), "pending-login.json");
+  return path58.join(path58.dirname(sessionPath()), "pending-login.json");
 }
 async function deviceStartPhase(opts, origin, deps) {
   const started = await startHandshake(opts, origin, deps);
   const file = pendingLoginPath();
-  mkdirSync15(path57.dirname(file), { recursive: true });
+  mkdirSync15(path58.dirname(file), { recursive: true });
   writeFileSync25(file, `${JSON.stringify({ origin, ...started }, null, 2)}
 `, { mode: 384 });
   deps.openBrowser(started.verificationUrl);
@@ -20385,9 +20869,9 @@ async function deviceStartPhase(opts, origin, deps) {
 async function deviceWaitPhase(opts, deps) {
   const file = pendingLoginPath();
   let pending;
-  if (existsSync47(file)) {
+  if (existsSync48(file)) {
     try {
-      const parsed = JSON.parse(readFileSync43(file, "utf8"));
+      const parsed = JSON.parse(readFileSync44(file, "utf8"));
       if (typeof parsed.origin === "string" && typeof parsed.deviceCode === "string" && typeof parsed.intervalSeconds === "number") {
         pending = parsed;
       }
@@ -20529,10 +21013,10 @@ var figma_connect_exports = {};
 __export(figma_connect_exports, {
   runFigmaConnect: () => runFigmaConnect
 });
-import { existsSync as existsSync48, mkdirSync as mkdirSync16, readFileSync as readFileSync44, rmSync as rmSync11, writeFileSync as writeFileSync26 } from "node:fs";
-import path58 from "node:path";
+import { existsSync as existsSync49, mkdirSync as mkdirSync16, readFileSync as readFileSync45, rmSync as rmSync11, writeFileSync as writeFileSync26 } from "node:fs";
+import path59 from "node:path";
 function pendingConnectPath() {
-  return path58.join(path58.dirname(sessionPath()), "pending-figma-connect.json");
+  return path59.join(path59.dirname(sessionPath()), "pending-figma-connect.json");
 }
 function resolveOrigin2(opts) {
   const named = (opts.to ?? process.env["TENDRIL_PORTAL_URL"] ?? "").replace(/\/+$/, "");
@@ -20569,7 +21053,7 @@ async function runFigmaConnect(opts) {
   const started = await startConnect(opts, send, origin, token);
   if (opts.start === true) {
     const pending = { origin, ...started };
-    mkdirSync16(path58.dirname(pendingConnectPath()), { recursive: true });
+    mkdirSync16(path59.dirname(pendingConnectPath()), { recursive: true });
     writeFileSync26(pendingConnectPath(), `${JSON.stringify(pending, null, 2)}
 `, { mode: 384 });
     (opts.openBrowser ?? (() => {
@@ -20623,9 +21107,9 @@ async function startConnect(opts, send, origin, token) {
 async function waitPhase(opts, send) {
   const file = pendingConnectPath();
   let pending;
-  if (existsSync48(file)) {
+  if (existsSync49(file)) {
     try {
-      const parsed = JSON.parse(readFileSync44(file, "utf8"));
+      const parsed = JSON.parse(readFileSync45(file, "utf8"));
       if (typeof parsed.origin === "string" && typeof parsed.connectId === "string") pending = parsed;
     } catch {
     }
@@ -20823,6 +21307,314 @@ var init_share = __esm({
   }
 });
 
+// packages/cli/src/commands/pull.ts
+var pull_exports = {};
+__export(pull_exports, {
+  recordingSlug: () => recordingSlug,
+  runPull: () => runPull
+});
+import { createHash as createHash15 } from "node:crypto";
+import { existsSync as existsSync50, mkdirSync as mkdirSync17, mkdtempSync as mkdtempSync4, readFileSync as readFileSync46, readdirSync as readdirSync19, renameSync as renameSync2, rmSync as rmSync12, writeFileSync as writeFileSync27 } from "node:fs";
+import { tmpdir } from "node:os";
+import path60 from "node:path";
+function setHashFromDisk(dir) {
+  const manifest = path60.join(dir, "recording-set.json");
+  if (!existsSync50(manifest)) return { ok: false, refusal: "it carries no recording-set.json" };
+  const shape = readSetShape(new Uint8Array(readFileSync46(manifest)));
+  if (!shape.ok) return { ok: false, refusal: shape.refusal };
+  const enumeration = recordingSetEnumeration(
+    { channeled: shape.shape.channeled, reps: shape.shape.reps },
+    {
+      exists: (relPath) => existsSync50(path60.join(dir, relPath)),
+      listRep: (rep) => existsSync50(path60.join(dir, rep)) ? readdirSync19(path60.join(dir, rep)) : []
+    }
+  );
+  return { ok: true, setHash: hashRecordingSet(enumeration, (relPath) => new Uint8Array(readFileSync46(path60.join(dir, relPath))), sha256) };
+}
+function recordingSlug(componentName) {
+  const collapsed = componentName.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  return collapsed === "" ? "recording-set" : collapsed;
+}
+function portalClient(opts) {
+  if (opts.client !== void 0) return opts.client;
+  const origin = resolveOrigin({ to: opts.to });
+  if (origin === "") {
+    fail(opts, ExitCode.InputValidation, {
+      error: "no portal to pull from",
+      code: "no-portal-configured",
+      remediation: "Pass --to <url> or set TENDRIL_PORTAL_URL. Recording sets live in the account that published them."
+    });
+  }
+  if (!isSecureOrigin(origin)) {
+    fail(opts, ExitCode.InputValidation, {
+      error: `${origin} is not https, so a session token sent there would travel in the clear`,
+      code: "portal-not-https",
+      remediation: "Use the https:// address of your portal. Only 127.0.0.1 and localhost are exempt, for local development."
+    });
+  }
+  const found = tokenFor(origin);
+  if (!found.ok && found.reason === "origin-mismatch") {
+    fail(opts, ExitCode.Auth, {
+      error: `the session available here belongs to ${found.boundTo}, and this would ask ${origin}`,
+      code: "session-belongs-to-another-portal",
+      remediation: "Sign in to the portal that holds these recordings."
+    });
+  }
+  if (!found.ok) {
+    fail(opts, ExitCode.Auth, {
+      error: `no session for ${origin}`,
+      code: "not-signed-in",
+      remediation: "A recording set belongs to the account that published it, so this one call needs you signed in. Agents: run tendril_login \u2014 the user signs in with ONE browser Approve, then re-run this. (Verifying a bundle you already have needs no account, ever.)"
+    });
+  }
+  return new HttpPublishClient({ origin, token: found.token });
+}
+async function runPull(opts) {
+  const component = opts.component.trim();
+  if (component === "") {
+    fail(opts, ExitCode.InputValidation, {
+      error: "name the component whose recording set you want",
+      code: "pull-names-no-component",
+      remediation: `Use the name your library shows, e.g. \`${tendrilCommand('pull "Radio group"')}\`.`
+    });
+  }
+  const client = portalClient(opts);
+  if (client.resolveRecordings === void 0 || client.downloadRecordings === void 0) {
+    fail(opts, ExitCode.General, {
+      error: "this client cannot pull recordings",
+      code: "pull-unsupported-client",
+      remediation: "Update the CLI (npx resolves @latest on its own; a pinned install wants a newer @tendrilapp/cli)."
+    });
+  }
+  emitProgress(0, 3, "asking the portal which publication holds these recordings");
+  const resolved = await client.resolveRecordings({ component, ...opts.figmaFile === void 0 ? {} : { figmaFile: opts.figmaFile } });
+  if (!resolved.ok) {
+    const authFailed = resolved.status === 401 || resolved.status === 403;
+    if (resolved.status === 404 && resolved.candidates === void 0) {
+      fail(opts, ExitCode.General, {
+        error: "this portal does not carry recording sets yet",
+        code: "pull-unsupported-portal",
+        remediation: "Nothing is wrong with what you asked for. The recordings have to come from the machine that recorded them until this portal is updated \u2014 copy the recording-set directory across, or re-publish from that machine once it is."
+      });
+    }
+    fail(opts, authFailed ? ExitCode.Auth : ExitCode.InputValidation, {
+      error: resolved.refusal,
+      code: authFailed ? "pull-not-signed-in" : "pull-not-resolved",
+      remediation: authFailed ? "This session is no longer valid for that portal. Agents: run tendril_login \u2014 the user signs in with ONE browser Approve, then re-run this. (Verifying a bundle you already have needs no account, ever.)" : resolved.candidates === void 0 || resolved.candidates.length === 0 ? `Publish the component from the machine that holds its recordings first \u2014 a publish carries them by default.` : `Pull one of these instead: ${resolved.candidates.map((c) => `${quoteArg(c.componentName)}${c.figmaFile === "unidentified" ? "" : ` (--figma-file ${c.figmaFile})`}${c.carried ? "" : " \u2014 carries no recording set"}`).join("; ")}`
+    });
+  }
+  const answer = resolved.value;
+  emitProgress(1, 3, `downloading ${String(answer.sizeBytes)} bytes of recorded design`);
+  const downloaded = await client.downloadRecordings({ publicationId: answer.publicationId });
+  if (!downloaded.ok) {
+    fail(opts, downloaded.status === 401 || downloaded.status === 403 ? ExitCode.Auth : ExitCode.General, {
+      error: downloaded.refusal,
+      code: "pull-download-refused",
+      remediation: "Try again; if the portal keeps refusing, re-publish the component from the machine that holds its recordings."
+    });
+  }
+  const bytes = downloaded.value;
+  if (bytes.length > MAX_ARCHIVE_BYTES) {
+    fail(opts, ExitCode.General, {
+      error: `the portal returned ${String(bytes.length)} bytes for a recording set, and no archive may exceed ${String(MAX_ARCHIVE_BYTES)}`,
+      code: "pull-archive-too-large",
+      remediation: "Nothing was written. Check that TENDRIL_PORTAL_URL points at your portal and not at something in between."
+    });
+  }
+  const actual = sha256([bytes]);
+  if (actual !== answer.contentSha256) {
+    fail(opts, ExitCode.General, {
+      error: `the downloaded recording set is not the one the portal named (got ${actual.slice(0, 12)}\u2026, expected ${answer.contentSha256.slice(0, 12)}\u2026)`,
+      code: "pull-bytes-do-not-match",
+      remediation: "Run this again. If it repeats, something between you and the portal is changing the response."
+    });
+  }
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    fail(opts, ExitCode.General, {
+      error: "the downloaded recording set is not UTF-8 text",
+      code: "pull-archive-unreadable",
+      remediation: "Run this again; if it repeats, re-publish the component."
+    });
+    return;
+  }
+  const validated = validateRecordingArchive(text, { sha256, expectedSetHash: answer.setHash });
+  if (!validated.ok) {
+    fail(opts, ExitCode.General, {
+      error: validated.refusal,
+      code: "pull-archive-refused",
+      remediation: "Nothing was written. Re-publish the component from the machine that holds its recordings, then pull again."
+    });
+    return;
+  }
+  const carried = validated.shape;
+  const carriedKit = carried.figmaFile?.trim();
+  if (carriedKit !== void 0 && carriedKit !== "" && answer.figmaFile !== "unidentified" && carriedKit !== answer.figmaFile.trim()) {
+    fail(opts, ExitCode.General, {
+      error: `the portal says this recording set belongs to design system ${answer.figmaFile}, and the set itself says ${carried.figmaFile}`,
+      code: "pull-identity-disagrees",
+      remediation: "Nothing was written. Re-publish the component from the machine that holds its recordings; if this repeats, the portal is answering about a different publication than the one it served."
+    });
+    return;
+  }
+  const slug = recordingSlug(component);
+  const dest = path60.resolve(process.cwd(), opts.dest ?? path60.join("recordings", slug));
+  if (existsSync50(dest)) {
+    const existing = existingSetHash(dest);
+    if (existing === validated.setHash) {
+      emitData(
+        opts,
+        {
+          component: carried.component,
+          ...answer.componentName === carried.component ? {} : { libraryLabel: answer.componentName },
+          figmaFile: carried.figmaFile ?? "unidentified",
+          setHash: validated.setHash,
+          dir: dest,
+          files: validated.members.size,
+          alreadyHere: true
+        },
+        () => {
+          process.stdout.write(`already here \u2014 ${dest}
+`);
+          process.stdout.write(`  the same recording set (${validated.setHash.slice(0, 12)}\u2026), nothing to do
+`);
+        }
+      );
+      return;
+    }
+    fail(opts, ExitCode.InputValidation, {
+      error: existing === void 0 ? `${dest} already exists and is not a recording set \u2014 pulling would write into it` : `${dest} already holds a DIFFERENT recording set (${existing.slice(0, 12)}\u2026 here, ${validated.setHash.slice(0, 12)}\u2026 on the portal)`,
+      code: "pull-destination-occupied",
+      remediation: `Move it aside and pull again, or pull somewhere else with \`--dest <dir>\`. Nothing is overwritten \u2014 a recording set is the ground truth a verdict was measured against, and replacing one silently is how a verdict comes to describe bytes nobody has.`
+    });
+  }
+  emitProgress(2, 3, "unpacking and re-deriving the set hash from disk");
+  const staging = mkdtempSync4(path60.join(tmpdir(), "tendril-pull-"));
+  let refusal;
+  try {
+    for (const [relPath, memberBytes] of validated.members) {
+      const target = path60.join(staging, relPath);
+      mkdirSync17(path60.dirname(target), { recursive: true });
+      writeFileSync27(target, memberBytes);
+    }
+    const fromDisk = setHashFromDisk(staging);
+    if (!fromDisk.ok) {
+      refusal = {
+        exit: ExitCode.General,
+        error: `the recording set did not survive being written to this filesystem \u2014 ${fromDisk.refusal}`,
+        code: "pull-set-changed-on-disk",
+        remediation: "Nothing was written where you asked, and nothing was left behind. This means the filesystem altered the files on the way down \u2014 pull onto a different volume with `--dest <dir>`."
+      };
+    } else if (fromDisk.setHash !== validated.setHash) {
+      refusal = {
+        exit: ExitCode.General,
+        error: `the recording set does not survive being written to this filesystem (on disk it derives ${fromDisk.setHash.slice(0, 12)}\u2026, the portal's is ${validated.setHash.slice(0, 12)}\u2026)`,
+        code: "pull-set-changed-on-disk",
+        remediation: "Nothing was written where you asked, and nothing was left behind. This usually means the filesystem renamed a file \u2014 pull onto a different volume with `--dest <dir>`."
+      };
+    } else {
+      mkdirSync17(path60.dirname(dest), { recursive: true });
+      try {
+        renameSync2(staging, dest);
+      } catch (error) {
+        const code = error.code;
+        if (code === "EEXIST" || code === "ENOTEMPTY") {
+          refusal = {
+            exit: ExitCode.InputValidation,
+            error: `${dest} appeared while this was verifying \u2014 on a case-insensitive filesystem it may be a directory whose name differs only in capitals`,
+            code: "pull-destination-collided",
+            remediation: `Pull somewhere else with \`--dest <dir>\`, or move the existing directory aside.`
+          };
+        } else if (code === "EXDEV") {
+          const beside = `${dest}.tendril-partial`;
+          rmSync12(beside, { recursive: true, force: true });
+          try {
+            copyTree(staging, beside);
+            renameSync2(beside, dest);
+          } finally {
+            rmSync12(beside, { recursive: true, force: true });
+          }
+        } else {
+          throw error;
+        }
+      }
+    }
+  } finally {
+    rmSync12(staging, { recursive: true, force: true });
+  }
+  if (refusal !== void 0) {
+    fail(opts, refusal.exit, { error: refusal.error, code: refusal.code, remediation: refusal.remediation });
+  }
+  emitData(
+    opts,
+    {
+      // THE CARRIED MANIFEST'S OWN NAME, not the portal's label — the
+      // pinned identity rather than the steerable one. `libraryLabel`
+      // carries the portal's word for it, named as what it is, and only
+      // when the two differ (`publish --name` makes that legitimate).
+      component: carried.component,
+      ...answer.componentName === carried.component ? {} : { libraryLabel: answer.componentName },
+      figmaFile: carried.figmaFile ?? "unidentified",
+      publicationId: answer.publicationId,
+      setHash: validated.setHash,
+      dir: dest,
+      files: validated.members.size,
+      alreadyHere: false
+    },
+    () => {
+      process.stdout.write(`pulled ${carried.component} \u2014 ${String(validated.members.size)} recorded files
+`);
+      if (answer.componentName !== carried.component) {
+        process.stdout.write(`  your library calls it ${quoteArg(answer.componentName)}; the recording set names itself ${quoteArg(carried.component)}
+`);
+      }
+      process.stdout.write(`  ${dest}
+`);
+      process.stdout.write(`  set ${validated.setHash.slice(0, 12)}\u2026 \u2014 the recordings this component's verdict was measured against
+`);
+      if (recordingSlug(component) !== component && opts.dest === void 0) {
+        process.stdout.write(`  (${quoteArg(component)} lands in the directory ${slug})
+`);
+      }
+      process.stdout.write(`  next: \`${tendrilCommand(`record status --set ${quoteArg(path60.relative(process.cwd(), dest) || dest)}`)}\`
+`);
+    }
+  );
+}
+function existingSetHash(dir) {
+  const derived = setHashFromDisk(dir);
+  return derived.ok ? derived.setHash : void 0;
+}
+function copyTree(from, to) {
+  mkdirSync17(to, { recursive: true });
+  for (const entry of readdirSync19(from, { withFileTypes: true })) {
+    const src = path60.join(from, entry.name);
+    const dst = path60.join(to, entry.name);
+    if (entry.isDirectory()) copyTree(src, dst);
+    else writeFileSync27(dst, readFileSync46(src));
+  }
+}
+var MAX_ARCHIVE_BYTES, sha256;
+var init_pull = __esm({
+  "packages/cli/src/commands/pull.ts"() {
+    "use strict";
+    init_src3();
+    init_src4();
+    init_invocation();
+    init_output();
+    init_publish_client();
+    init_publish();
+    MAX_ARCHIVE_BYTES = 2e7;
+    sha256 = (chunks) => {
+      const h = createHash15("sha256");
+      for (const chunk of chunks) h.update(chunk);
+      return h.digest("hex");
+    };
+  }
+});
+
 // packages/cli/src/commands/generate-route.ts
 var generate_route_exports = {};
 __export(generate_route_exports, {
@@ -20847,17 +21639,17 @@ __export(generate_recorded_exports, {
   runGenerateRecorded: () => runGenerateRecorded
 });
 import { confirm as confirm3, isCancel as isCancel4 } from "@clack/prompts";
-import { existsSync as existsSync49, readFileSync as readFileSync45 } from "node:fs";
-import path59 from "node:path";
+import { existsSync as existsSync51, readFileSync as readFileSync47 } from "node:fs";
+import path61 from "node:path";
 async function runGenerateRecorded(opts) {
   const callerCwd = process.env["INIT_CWD"] ?? process.cwd();
-  const outDirAbs = path59.resolve(callerCwd, opts.out);
-  const recordedAsPath = path59.resolve(callerCwd, opts.recorded);
+  const outDirAbs = path61.resolve(callerCwd, opts.out);
+  const recordedAsPath = path61.resolve(callerCwd, opts.recorded);
   let task;
   let taskName;
   let authoredApi;
   let composition;
-  const isSet = existsSync49(path59.join(recordedAsPath, "recording-set.json"));
+  const isSet = existsSync51(path61.join(recordedAsPath, "recording-set.json"));
   const registry = TASKS[opts.recorded];
   if (registry !== void 0 && !isSet) {
     task = registry;
@@ -20866,7 +21658,7 @@ async function runGenerateRecorded(opts) {
     try {
       const authored = authorTaskFromSet(recordedAsPath);
       task = authored.task;
-      taskName = path59.basename(recordedAsPath);
+      taskName = path61.basename(recordedAsPath);
       authoredApi = authored.api;
       const roles = RolesSchema.safeParse(loadManifest(recordedAsPath).roles);
       if (roles.success) composition = roles.data;
@@ -20900,7 +21692,7 @@ async function runGenerateRecorded(opts) {
     warn(opts, `font weights (advisory): the recording implies weights ${g.declared.join(", ")} for "${g.family}" \u2014 cache provides ${g.provided.join(", ")}; nearest-weight rendering may shift stroke density (certification stays family-gated; implied weights can leak across families)`);
   }
   const missing = task.configs.filter(
-    (c) => !repEnvelopeExists(task.set, c.rep, "screenshot") || !repEnvelopeExists(task.set, c.rep, "metadata") || !existsSync49(path59.join(task.set, c.rep, "get_design_context.json"))
+    (c) => !repEnvelopeExists(task.set, c.rep, "screenshot") || !repEnvelopeExists(task.set, c.rep, "metadata") || !existsSync51(path61.join(task.set, c.rep, "get_design_context.json"))
   );
   if (missing.length > 0) {
     fail(opts, ExitCode.RecordingIncomplete, {
@@ -20970,8 +21762,8 @@ async function runGenerateRecorded(opts) {
 ` : `${line}
 `);
   if (opts.dryRun) {
-    emitData(opts, { dryRun: true, task: taskName, model: modelId, consent, wouldWrite: path59.join(outDirAbs, taskName) }, () => {
-      process.stdout.write(`dry-run: nothing sent, nothing written (would write ${path59.join(outDirAbs, taskName)})
+    emitData(opts, { dryRun: true, task: taskName, model: modelId, consent, wouldWrite: path61.join(outDirAbs, taskName) }, () => {
+      process.stdout.write(`dry-run: nothing sent, nothing written (would write ${path61.join(outDirAbs, taskName)})
 `);
     });
     return;
@@ -20994,10 +21786,10 @@ async function runGenerateRecorded(opts) {
       });
     }
   }
-  const bundleDir = path59.join(outDirAbs, taskName);
-  if (existsSync49(path59.join(bundleDir, "component.json"))) {
+  const bundleDir = path61.join(outDirAbs, taskName);
+  if (existsSync51(path61.join(bundleDir, "component.json"))) {
     try {
-      const prior = readBundleManifest(readFileSync45(path59.join(bundleDir, "component.json"), "utf8")).manifest;
+      const prior = readBundleManifest(readFileSync47(path61.join(bundleDir, "component.json"), "utf8")).manifest;
       if (prior !== void 0 && prior.provenance.recordingSet.hash !== recordingSetHash(task.set, task.configs)) {
         fail(opts, ExitCode.InputValidation, {
           error: `${bundleDir} already holds a bundle bound to recording set "${prior.provenance.recordingSet.path}" \u2014 generating here against a different set would silently rewrite its verification identity`,
@@ -22329,9 +23121,10 @@ function buildProgram() {
       ...local["revoke"] !== void 0 ? { revoke: local["revoke"] } : {}
     });
   });
-  program.command("publish").description("Put a verified bundle and its evidence on a page, at a URL you can send to someone. Refuses a run the ruler declined.").argument("<bundleDir>", "bundle directory that has already been verified").option("--to <url>", "the portal to publish to (or set TENDRIL_PORTAL_URL)").option("--name <name>", "library label for this component (default: the bundle manifest's own name)").option("--approve-start", "first publish only: request the browser approval, print the link, persist the pending state and exit \u2014 the tendril_publish tool's phase one").option("--approve-wait", "resume a pending approval: poll until the human decides in the browser, then publish \u2014 phase two").option("--wait-window <seconds>", "with --approve-wait: return after this many undecided seconds (exit 0, status approval-pending, the pending slot kept) instead of blocking to the 31-minute cap \u2014 the MCP bridge's bounded-poll shape").action(async (bundleDir, _o, cmd) => {
+  program.command("publish").description("Put a verified bundle and its evidence on a page, at a URL you can send to someone. Refuses a run the ruler declined.").argument("<bundleDir>", "bundle directory that has already been verified").option("--to <url>", "the portal to publish to (or set TENDRIL_PORTAL_URL)").option("--name <name>", "library label for this component (default: the bundle manifest's own name)").option("--approve-start", "first publish only: request the browser approval, print the link, persist the pending state and exit \u2014 the tendril_publish tool's phase one").option("--approve-wait", "resume a pending approval: poll until the human decides in the browser, then publish \u2014 phase two").option("--wait-window <seconds>", "with --approve-wait: return after this many undecided seconds (exit 0, status approval-pending, the pending slot kept) instead of blocking to the 31-minute cap \u2014 the MCP bridge's bounded-poll shape").option("--recordings <dir>", "the recording set to carry, when the bundle's stamped path is stale (a bundle moved between machines usually has one)").option("--no-recordings", "publish without carrying the recording set \u2014 the component still publishes, but no other machine can pull the recordings it was measured against").action(async (bundleDir, _o, cmd) => {
     const flags = globalFlags(cmd.parent);
     const local = cmd.opts();
+    const argv = cmd.parent?.args ?? process.argv;
     const { runPublish: runPublish2 } = await Promise.resolve().then(() => (init_publish(), publish_exports));
     await runPublish2({
       ...flags,
@@ -22342,7 +23135,33 @@ function buildProgram() {
       ...local["approveWait"] !== void 0 ? { approveWait: local["approveWait"] } : {},
       // Parsed, never filtered: a bad value must refuse loudly in
       // runPublish, not silently become the unbounded wait.
-      ...local["waitWindow"] !== void 0 ? { waitWindowSeconds: Number.parseFloat(local["waitWindow"]) } : {}
+      ...local["waitWindow"] !== void 0 ? { waitWindowSeconds: Number.parseFloat(local["waitWindow"]) } : {},
+      // OPT-OUT WINS, whatever the order. Commander merges these into
+      // one option with last-flag-wins, so `--no-recordings
+      // --recordings X` CARRIED — a user who wrote the opt-out and
+      // then a directory got the custody expansion anyway. For a flag
+      // whose whole job is declining to upload the customer's design
+      // structure, argument order is not a thing to be clever about.
+      ...argv.includes("--no-recordings") ? { noRecordings: true } : {},
+      // `--recordings <dir>` and `--no-recordings` are ONE commander
+      // option, so the value is a string, `false`, or the default
+      // `true`. Splitting it here keeps the two meanings apart in the
+      // options object rather than making the command re-read
+      // commander's convention.
+      ...typeof local["recordings"] === "string" ? { recordings: local["recordings"] } : {},
+      ...local["recordings"] === false ? { noRecordings: true } : {}
+    });
+  });
+  program.command("pull").description("Bring a published component's RECORDING SET onto this machine \u2014 the design truth its verdict was measured against, so a machine with only portal access can carry the work on.").argument("<component>", "the component name, exactly as your library shows it").option("--figma-file <key>", "the design system, when one name spans several of yours").option("--dest <dir>", "where the set lands (default: ./recordings/<component>)").option("--to <url>", "the portal to pull from (or set TENDRIL_PORTAL_URL)").action(async (component, _o, cmd) => {
+    const flags = globalFlags(cmd.parent);
+    const local = cmd.opts();
+    const { runPull: runPull2 } = await Promise.resolve().then(() => (init_pull(), pull_exports));
+    await runPull2({
+      ...flags,
+      component,
+      ...local["figmaFile"] !== void 0 ? { figmaFile: local["figmaFile"] } : {},
+      ...local["dest"] !== void 0 ? { dest: local["dest"] } : {},
+      ...local["to"] !== void 0 ? { to: local["to"] } : {}
     });
   });
   program.command("verify").description("Recompute verification for a generated bundle against its recording set (per-config status, behaviors, honest exit codes).").argument("<bundleDir>", "bundle directory to verify").option("--task <name>", "legacy task adapter for bundles WITHOUT component.json (bundle v1 carries its own prop manifest)").option("--set <dir>", "recording set directory (overrides the bundle's provenance path)").option("--bar <bar>", "target bar: pass (0.95) or cert (0.97)", "pass").option("--library <dir>", "workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: current directory)").option("--profile <file>", "a `tendril profile` artifact; reports whether the bundle followed your codebase conventions (never gates the verdict)").option("--hover-timeout <ms>", "hover actionability budget in ms (default 2000) \u2014 for diagnosing a slow machine; a non-default value is recorded in the report as a verdict caveat, never silently").action(async (bundleDir, _opts, cmd) => {